@ryanfw/prompt-orchestration-pipeline 0.6.0 → 0.7.0

package/src/providers/openai.js

@@ -4,6 +4,8 @@ import {
   isRetryableError,
   sleep,
   tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
 } from "./base.js";
 
 let client = null;
@@ -31,9 +33,7 @@ export async function openaiChat({
   temperature,
   maxTokens,
   max_tokens, // Explicitly destructure to prevent it from being in ...rest
-  responseFormat = "json", // Default to JSON for legacy compatibility
-  tools,
-  toolChoice,
+  responseFormat,
   seed,
   stop,
   topP,
@@ -46,6 +46,9 @@ export async function openaiChat({
   console.log("[OpenAI] Model:", model);
   console.log("[OpenAI] Response format:", responseFormat);
 
+  // Enforce JSON mode - reject calls without proper JSON responseFormat
+  ensureJsonResponseFormat(responseFormat, "OpenAI");
+
   const openai = getClient();
   if (!openai) throw new Error("OpenAI API key not configured");
 
@@ -106,22 +109,19 @@ export async function openaiChat({
           total_tokens: promptTokens + completionTokens,
         };
 
-        // Parse JSON if requested
-        let parsed = null;
-        if (
-          responseFormat?.json_schema ||
-          responseFormat?.type === "json_object" ||
-          responseFormat === "json"
-        ) {
-          parsed = tryParseJSON(text);
-          if (!parsed && attempt < maxRetries) {
-            lastError = new Error("Failed to parse JSON response");
-            continue;
-          }
+        // Parse JSON - this is now required for all calls
+        const parsed = tryParseJSON(text);
+        if (!parsed) {
+          throw new ProviderJsonParseError(
+            "OpenAI",
+            model,
+            text.substring(0, 200),
+            "Failed to parse JSON response from Responses API"
+          );
         }
 
         console.log("[OpenAI] Returning response from Responses API");
-        return { content: parsed ?? text, text, usage, raw: resp };
+        return { content: parsed, text, usage, raw: resp };
       }
 
       // ---------- CLASSIC CHAT COMPLETIONS path (non-GPT-5) ----------
@@ -136,8 +136,6 @@ export async function openaiChat({
         presence_penalty: presencePenalty,
         seed,
         stop,
-        tools,
-        tool_choice: toolChoice,
         stream: false,
       };
 
@@ -158,31 +156,19 @@ export async function openaiChat({
         classicText.length
       );
 
-      // If tool calls present, return them (test expects this)
-      if (classicRes?.choices?.[0]?.message?.tool_calls) {
-        return {
-          content: classicText,
-          usage: classicRes?.usage,
-          toolCalls: classicRes.choices[0].message.tool_calls,
-          raw: classicRes,
-        };
-      }
-
-      let classicParsed = null;
-      if (
-        responseFormat?.json_schema ||
-        responseFormat?.type === "json_object" ||
-        responseFormat === "json"
-      ) {
-        classicParsed = tryParseJSON(classicText);
-        if (!classicParsed && attempt < maxRetries) {
-          lastError = new Error("Failed to parse JSON response");
-          continue;
-        }
+      // Parse JSON - this is now required for all calls
+      const classicParsed = tryParseJSON(classicText);
+      if (!classicParsed) {
+        throw new ProviderJsonParseError(
+          "OpenAI",
+          model,
+          classicText.substring(0, 200),
+          "Failed to parse JSON response from Classic API"
+        );
       }
 
       return {
-        content: classicParsed ?? classicText,
+        content: classicParsed,
         text: classicText,
         usage: classicRes?.usage,
         raw: classicRes,
@@ -211,8 +197,6 @@ export async function openaiChat({
           presence_penalty: presencePenalty,
           seed,
           stop,
-          tools,
-          tool_choice: toolChoice,
           stream: false,
         };
 
@@ -227,17 +211,19 @@ export async function openaiChat({
         const classicRes = await openai.chat.completions.create(classicReq);
         const text = classicRes?.choices?.[0]?.message?.content ?? "";
 
-        let parsed = null;
-        if (
-          responseFormat?.json_schema ||
-          responseFormat?.type === "json_object" ||
-          responseFormat === "json"
-        ) {
-          parsed = tryParseJSON(text);
+        // Parse JSON - this is now required for all calls
+        const parsed = tryParseJSON(text);
+        if (!parsed) {
+          throw new ProviderJsonParseError(
+            "OpenAI",
+            model,
+            text.substring(0, 200),
+            "Failed to parse JSON response from fallback Classic API"
+          );
         }
 
         return {
-          content: parsed ?? text,
+          content: parsed,
           text,
           usage: classicRes?.usage,
           raw: classicRes,
@@ -256,59 +242,3 @@ export async function openaiChat({
 
   throw lastError || new Error(`Failed after ${maxRetries + 1} attempts`);
 }
-
-/**
- * Convenience helper used widely in the codebase.
- * For tests, this hits the Responses API directly (even for non-GPT-5).
- * Always attempts to coerce JSON on return (falls back to string).
- */
-export async function queryChatGPT(system, prompt, options = {}) {
-  console.log("\n[OpenAI] Starting queryChatGPT call");
-  console.log("[OpenAI] Model:", options.model || "gpt-5-chat-latest");
-
-  const openai = getClient();
-  if (!openai) throw new Error("OpenAI API key not configured");
-
-  const { systemMsg, userMsg } = extractMessages([
-    { role: "system", content: system },
-    { role: "user", content: prompt },
-  ]);
-  console.log("[OpenAI] System message length:", systemMsg.length);
-  console.log("[OpenAI] User message length:", userMsg.length);
-
-  const req = {
-    model: options.model || "gpt-5-chat-latest",
-    instructions: systemMsg,
-    input: userMsg,
-    max_output_tokens: options.maxTokens ?? 25000,
-  };
-
-  // Note: Responses API does not support temperature, top_p, frequency_penalty,
-  // presence_penalty, seed, or stop parameters. These are only for Chat Completions API.
-
-  // Response format / schema mapping for Responses API
-  if (options.schema) {
-    req.text = {
-      format: {
-        type: "json_schema",
-        name: options.schemaName || "Response",
-        schema: options.schema,
-      },
-    };
-  } else if (
-    options.response_format?.type === "json_object" ||
-    options.response_format === "json"
-  ) {
-    req.text = { format: { type: "json_object" } };
-  }
-
-  console.log("[OpenAI] Calling responses.create...");
-  const resp = await openai.responses.create(req);
-  const text = resp.output_text ?? "";
-  console.log("[OpenAI] Response received, text length:", text.length);
-
-  // Always try to parse JSON; fall back to string
-  const parsed = tryParseJSON(text);
-  console.log("[OpenAI] Parsed result:", parsed ? "JSON" : "text");
-  return parsed ?? text;
-}

package/src/providers/zhipu.js

@@ -0,0 +1,136 @@
+import {
+  extractMessages,
+  isRetryableError,
+  sleep,
+  tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
+} from "./base.js";
+
+export async function zhipuChat({
+  messages,
+  model = "glm-4-plus",
+  temperature = 0.7,
+  maxTokens = 8192,
+  responseFormat = "json",
+  topP,
+  stop,
+  maxRetries = 3,
+}) {
+  console.log("\n[Zhipu] Starting zhipuChat call");
+  console.log("[Zhipu] Model:", model);
+  console.log("[Zhipu] Response format:", responseFormat);
+
+  // Enforce JSON mode - reject calls without proper JSON responseFormat
+  ensureJsonResponseFormat(responseFormat, "Zhipu");
+
+  if (!process.env.ZHIPU_API_KEY) {
+    throw new Error("Zhipu API key not configured");
+  }
+
+  const { systemMsg, userMsg } = extractMessages(messages);
+  console.log("[Zhipu] System message length:", systemMsg.length);
+  console.log("[Zhipu] User message length:", userMsg.length);
+
+  // Build system guard for JSON enforcement
+  let system = systemMsg;
+
+  if (responseFormat === "json" || responseFormat?.type === "json_object") {
+    system = `${systemMsg}\n\nYou must output strict JSON only with no extra text.`;
+  }
+
+  if (responseFormat?.json_schema) {
+    system = `${systemMsg}\n\nYou must output strict JSON only matching this schema (no extra text):\n${JSON.stringify(responseFormat.json_schema)}`;
+  }
+
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (attempt > 0) {
+      await sleep(Math.pow(2, attempt) * 1000);
+    }
+
+    try {
+      console.log(`[Zhipu] Attempt ${attempt + 1}/${maxRetries + 1}`);
+
+      const requestBody = {
+        model,
+        messages: [
+          ...(system ? [{ role: "system", content: system }] : []),
+          { role: "user", content: userMsg },
+        ],
+        temperature,
+        max_tokens: maxTokens,
+        ...(topP !== undefined ? { top_p: topP } : {}),
+        ...(stop !== undefined ? { stop: stop } : {}),
+      };
+
+      console.log("[Zhipu] Calling Zhipu API...");
+      const response = await fetch("https://api.z.ai/api/coding/paas/v4", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${process.env.ZHIPU_API_KEY}`,
+        },
+        body: JSON.stringify(requestBody),
+      });
+
+      if (!response.ok) {
+        const error = await response
+          .json()
+          .catch(() => ({ error: response.statusText }));
+        throw { status: response.status, ...error };
+      }
+
+      const data = await response.json();
+      console.log("[Zhipu] Response received from Zhipu API");
+
+      // Extract text from response
+      const text = data?.choices?.[0]?.message?.content || "";
+      console.log("[Zhipu] Response text length:", text.length);
+
+      // Parse JSON - this is required for all calls
+      const parsed = tryParseJSON(text);
+      if (!parsed) {
+        throw new ProviderJsonParseError(
+          "Zhipu",
+          model,
+          text.substring(0, 200),
+          "Failed to parse JSON response from Zhipu API"
+        );
+      }
+
+      // Normalize usage (if provided)
+      const prompt_tokens = data?.usage?.prompt_tokens;
+      const completion_tokens = data?.usage?.completion_tokens;
+      const total_tokens = (prompt_tokens ?? 0) + (completion_tokens ?? 0);
+      const usage =
+        prompt_tokens != null && completion_tokens != null
+          ? { prompt_tokens, completion_tokens, total_tokens }
+          : undefined;
+
+      console.log("[Zhipu] Returning response from Zhipu API");
+      return {
+        content: parsed,
+        text,
+        ...(usage ? { usage } : {}),
+        raw: data,
+      };
+    } catch (error) {
+      lastError = error;
+      const msg = error?.error?.message || error?.message || "";
+      console.error("[Zhipu] Error occurred:", msg);
+      console.error("[Zhipu] Error status:", error?.status);
+
+      if (error.status === 401) throw error;
+
+      if (isRetryableError(error) && attempt < maxRetries) {
+        console.log("[Zhipu] Retrying due to retryable error");
+        continue;
+      }
+
+      if (attempt === maxRetries) throw error;
+    }
+  }
+
+  throw lastError || new Error(`Failed after ${maxRetries + 1} attempts`);
+}

package/src/ui/client/adapters/job-adapter.js

@@ -1,17 +1,24 @@
 import { derivePipelineMetadata } from "../../../utils/pipelines.js";
-
-const ALLOWED_STATES = new Set(["pending", "running", "done", "failed"]);
+import {
+  normalizeTaskState,
+  deriveJobStatusFromTasks,
+} from "../../../config/statuses.js";
 
 /**
  * Normalize a raw task state into canonical enum.
  * Returns { state, warning? } where warning is a string if normalization occurred.
  */
-function normalizeTaskState(raw) {
+function normalizeTaskStateWithWarning(raw) {
   if (!raw || typeof raw !== "string")
     return { state: "pending", warning: "missing_state" };
-  const s = raw.toLowerCase();
-  if (ALLOWED_STATES.has(s)) return { state: s };
-  return { state: "pending", warning: `unknown_state:${raw}` };
+
+  const normalizedState = normalizeTaskState(raw);
+
+  if (raw !== normalizedState) {
+    return { state: normalizedState, warning: `unknown_state:${raw}` };
+  }
+
+  return { state: normalizedState };
 }
 
 /**
@@ -28,7 +35,7 @@ function normalizeTasks(rawTasks) {
     // Object shape - canonical format
     const tasks = {};
     Object.entries(rawTasks).forEach(([name, t]) => {
-      const ns = normalizeTaskState(t && t.state);
+      const ns = normalizeTaskStateWithWarning(t && t.state);
       if (ns.warning) warnings.push(`${name}:${ns.warning}`);
       const taskObj = {
         name,
@@ -79,7 +86,7 @@ function normalizeTasks(rawTasks) {
     const tasks = {};
     rawTasks.forEach((t, idx) => {
       const name = t && t.name ? String(t.name) : `task-${idx}`;
-      const ns = normalizeTaskState(t && t.state);
+      const ns = normalizeTaskStateWithWarning(t && t.state);
       if (ns.warning) warnings.push(`${name}:${ns.warning}`);
       tasks[name] = {
         name,
@@ -112,23 +119,6 @@ function normalizeTasks(rawTasks) {
   return { tasks: {}, warnings: ["invalid_tasks_shape"] };
 }
 
-/**
- * Derive status from tasks when status is missing/invalid.
- * Rules:
- * - failed if any task state === 'failed'
- * - running if >=1 running and none failed
- * - complete if all done
- * - pending otherwise
- */
-function deriveStatusFromTasks(tasks) {
-  const taskList = Object.values(tasks);
-  if (!Array.isArray(taskList) || taskList.length === 0) return "pending";
-  if (taskList.some((t) => t.state === "failed")) return "failed";
-  if (taskList.some((t) => t.state === "running")) return "running";
-  if (taskList.every((t) => t.state === "done")) return "complete";
-  return "pending";
-}
-
 /**
  * Clamp number to 0..100 and ensure integer.
  */
@@ -147,7 +137,7 @@ function computeJobSummaryStats(tasks) {
     (acc, t) => acc + (t.state === "done" ? 1 : 0),
     0
   );
-  const status = deriveStatusFromTasks(tasks);
+  const status = deriveJobStatusFromTasks(Object.values(tasks));
   const progress =
     taskCount > 0 ? Math.round((doneCount / taskCount) * 100) : 0;
   return { status, progress, doneCount, taskCount };

package/src/ui/client/api.js

@@ -0,0 +1,134 @@
+/**
+ * Client-side API helpers for making HTTP requests to the backend
+ */
+
+/**
+ * Restart a job with clean-slate mode
+ *
+ * @param {string} jobId - The ID of the job to restart
+ * @param {Object} opts - Options object
+ * @param {Object} opts.options - Additional options for the restart
+ * @param {boolean} opts.options.clearTokenUsage - Whether to clear token usage (default: true)
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function restartJob(jobId, opts = {}) {
+  const options = {
+    clearTokenUsage: true,
+    ...opts.options,
+  };
+
+  const requestBody = opts.fromTask
+    ? { fromTask: opts.fromTask, options }
+    : { mode: "clean-slate", options };
+
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/restart`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message: getRestartErrorMessage(errorData, response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
+/**
+ * Map HTTP status codes to error codes for structured error handling
+ */
+function getErrorCodeFromStatus(status) {
+  switch (status) {
+    case 404:
+      return "job_not_found";
+    case 409:
+      return "conflict";
+    case 500:
+      return "spawn_failed";
+    default:
+      return "unknown_error";
+  }
+}
+
+/**
+ * Map HTTP status codes to error messages for structured error handling
+ */
+function getErrorMessageFromStatus(status) {
+  switch (status) {
+    case 404:
+      return "Job not found";
+    case 409:
+      return "Job restart conflict";
+    case 500:
+      return "Failed to start restart";
+    default:
+      return `Request failed with status ${status}`;
+  }
+}
+
+/**
+ * Get specific error message from error response for restart functionality
+ */
+function getRestartErrorMessage(errorData, status) {
+  // Handle specific 409 conflict errors
+  if (status === 409) {
+    if (errorData.code === "job_running") {
+      return "Job is currently running; restart is unavailable.";
+    }
+    if (errorData.code === "unsupported_lifecycle") {
+      return "Job must be in current to restart.";
+    }
+    if (errorData.message?.includes("job_running")) {
+      return "Job is currently running; restart is unavailable.";
+    }
+    if (errorData.message?.includes("unsupported_lifecycle")) {
+      return "Job must be in current to restart.";
+    }
+  }
+
+  // Handle 404 errors
+  if (status === 404) {
+    return "Job not found.";
+  }
+
+  // Handle 500 errors
+  if (status === 500) {
+    return "Failed to start restart. Try again.";
+  }
+
+  // Fall back to provided message or default
+  return errorData.message || "Failed to restart job.";
+}