@ryanfw/prompt-orchestration-pipeline 0.5.0 → 0.7.0

package/src/providers/gemini.js

@@ -0,0 +1,226 @@
+import {
+  extractMessages,
+  isRetryableError,
+  sleep,
+  tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
+} from "./base.js";
+
+/**
+ * Google Gemini provider implementation
+ *
+ * @param {Object} options - Provider options
+ * @param {Array} options.messages - Message array with system and user roles
+ * @param {string} options.model - Model name (default: "gemini-2.5-flash")
+ * @param {number} options.temperature - Temperature for sampling (default: 0.7)
+ * @param {number} options.maxTokens - Maximum tokens in response
+ * @param {string|Object} options.responseFormat - Response format ("json" or schema object)
+ * @param {number} options.topP - Top-p sampling parameter
+ * @param {string} options.stop - Stop sequence
+ * @param {number} options.maxRetries - Maximum retry attempts (default: 3)
+ * @returns {Promise<Object>} Provider response with content, text, usage, and raw response
+ */
+export async function geminiChat(options) {
+  const {
+    messages,
+    model = "gemini-2.5-flash",
+    temperature = 0.7,
+    maxTokens,
+    responseFormat,
+    topP,
+    frequencyPenalty,
+    presencePenalty,
+    stop,
+    maxRetries = 3
+  } = options;
+
+  // Validate response format (Gemini only supports JSON mode)
+  ensureJsonResponseFormat(responseFormat, "Gemini");
+
+  // Check API key
+  if (!process.env.GEMINI_API_KEY) {
+    throw new Error("Gemini API key not configured");
+  }
+
+  // Extract system and user messages
+  const { systemMsg, userMsg } = extractMessages(messages);
+
+  // Build system instruction for JSON enforcement
+  let systemInstruction = systemMsg;
+  if (responseFormat === "json" || responseFormat?.type === "json_object") {
+    systemInstruction = `${systemMsg}\n\nYou must output strict JSON only with no extra text.`;
+  }
+  if (responseFormat?.json_schema) {
+    systemInstruction = `${systemMsg}\n\nYou must output strict JSON only matching this schema (no extra text):\n${JSON.stringify(responseFormat.json_schema)}`;
+  }
+
+  // Prepare request body
+  const requestBody = {
+    contents: [
+      {
+        parts: [
+          {
+            text: userMsg,
+          },
+        ],
+      },
+    ],
+    generationConfig: {
+      temperature,
+      maxOutputTokens: maxTokens,
+      topP,
+      stopSequences: stop ? [stop] : undefined,
+    },
+    safetySettings: [
+      {
+        category: "HARM_CATEGORY_HARASSMENT",
+        threshold: "BLOCK_NONE",
+      },
+      {
+        category: "HARM_CATEGORY_HATE_SPEECH",
+        threshold: "BLOCK_NONE",
+      },
+      {
+        category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        threshold: "BLOCK_NONE",
+      },
+      {
+        category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+        threshold: "BLOCK_NONE",
+      },
+    ],
+  };
+
+  // Add system instruction if provided
+  if (systemInstruction.trim()) {
+    requestBody.systemInstruction = {
+      parts: [
+        {
+          text: systemInstruction,
+        },
+      ],
+    };
+  }
+
+  // Remove undefined values
+  if (topP === undefined) delete requestBody.generationConfig.topP;
+  if (stop === undefined) delete requestBody.generationConfig.stopSequences;
+
+  let lastError;
+  const baseUrl =
+    process.env.GEMINI_BASE_URL ||
+    "https://generativelanguage.googleapis.com/v1beta";
+  const url = `${baseUrl}/models/${model}:generateContent?key=${process.env.GEMINI_API_KEY}`;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (attempt > 0) {
+      await sleep(2 ** attempt * 1000); // Exponential backoff
+    }
+
+    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}`
+      );
+      console.log(`[Gemini] User message length: ${userMsg.length}`);
+
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = new Error(
+          errorData.error?.message || `Gemini API error: ${response.statusText}`
+        );
+        error.status = response.status;
+        error.data = errorData;
+
+        // Don't retry on authentication errors
+        if (response.status === 401) {
+          throw error;
+        }
+
+        // Retry on retryable errors
+        if (isRetryableError(error) && attempt < maxRetries) {
+          console.log(`[Gemini] Retryable error, retrying...`);
+          lastError = error;
+          continue;
+        }
+
+        throw error;
+      }
+
+      const data = await response.json();
+      console.log(
+        `[Gemini] Response received, candidates length: ${data.candidates?.length || 0}`
+      );
+
+      // Extract text from response
+      const candidate = data.candidates?.[0];
+      if (!candidate?.content?.parts?.[0]?.text) {
+        throw new Error("No content returned from Gemini API");
+      }
+
+      const text = candidate.content.parts[0].text;
+      console.log(`[Gemini] Text length: ${text.length}`);
+
+      // Parse JSON if required
+      const parsed = tryParseJSON(text);
+      if (responseFormat && !parsed) {
+        throw new ProviderJsonParseError(
+          "Gemini",
+          model,
+          text.substring(0, 200),
+          "Failed to parse JSON response from Gemini API"
+        );
+      }
+
+      // Normalize usage metrics
+      const usage = data.usageMetadata
+        ? {
+            prompt_tokens: data.usageMetadata.promptTokenCount,
+            completion_tokens: data.usageMetadata.candidatesTokenCount,
+            total_tokens: data.usageMetadata.totalTokenCount,
+          }
+        : undefined;
+
+      console.log(`[Gemini] Usage:`, usage);
+
+      return {
+        content: parsed || text,
+        text,
+        ...(usage ? { usage } : {}),
+        raw: data,
+      };
+    } catch (error) {
+      console.error(`[Gemini] Error occurred: ${error.message}`);
+      console.error(`[Gemini] Error status: ${error.status}`);
+
+      lastError = error;
+
+      // Don't retry on authentication errors
+      if (error.status === 401) {
+        throw error;
+      }
+
+      // Continue retrying for other errors
+      if (attempt < maxRetries) {
+        continue;
+      }
+
+      throw lastError;
+    }
+  }
+
+  throw lastError;
+}

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, // { type: 'json_object' } | { json_schema, name } | 'json'
-  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`);
+}