@ryanfw/prompt-orchestration-pipeline 0.6.0 → 0.8.0

package/src/providers/anthropic.js

@@ -1,54 +1,38 @@
-import Anthropic from "@anthropic-ai/sdk";
 import {
   extractMessages,
   isRetryableError,
   sleep,
   tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
 } from "./base.js";
 
-let client = null;
-
-function getClient() {
-  if (!client && process.env.ANTHROPIC_API_KEY) {
-    client = new Anthropic({
-      apiKey: process.env.ANTHROPIC_API_KEY,
-      baseURL: process.env.ANTHROPIC_BASE_URL,
-    });
-  }
-  return client;
-}
-
 export async function anthropicChat({
   messages,
-  model = "claude-3-opus-20240229",
+  model = "claude-3-sonnet",
   temperature = 0.7,
-  maxTokens = 4096,
-  responseFormat,
+  maxTokens = 8192,
+  responseFormat = "json",
   topP,
-  topK,
-  stopSequences,
+  stop,
   maxRetries = 3,
 }) {
-  const anthropic = getClient();
-  if (!anthropic) throw new Error("Anthropic API key not configured");
-
-  const { systemMsg, userMessages, assistantMessages } =
-    extractMessages(messages);
-
-  // Convert messages to Anthropic format
-  const anthropicMessages = [];
-  for (const msg of messages) {
-    if (msg.role === "user" || msg.role === "assistant") {
-      anthropicMessages.push({
-        role: msg.role,
-        content: msg.content,
-      });
-    }
-  }
+  console.log("\n[Anthropic] Starting anthropicChat call");
+  console.log("[Anthropic] Model:", model);
+  console.log("[Anthropic] 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);
+
+  // Build system guard for JSON enforcement
+  let system = systemMsg;
 
-  // Ensure messages alternate and start with user
-  if (anthropicMessages.length === 0 || anthropicMessages[0].role !== "user") {
-    anthropicMessages.unshift({ role: "user", content: "Hello" });
+  if (responseFormat === "json" || responseFormat?.type === "json_object") {
+    system = `${systemMsg}\n\nYou must output strict JSON only with no extra text.`;
   }
 
   let lastError;
@@ -58,54 +42,84 @@ export async function anthropicChat({
     }
 
     try {
-      const request = {
+      console.log(`[Anthropic] Attempt ${attempt + 1}/${maxRetries + 1}`);
+
+      const requestBody = {
         model,
-        messages: anthropicMessages,
-        max_tokens: maxTokens,
+        system,
+        messages: [{ role: "user", content: userMsg }],
         temperature,
-        top_p: topP,
-        top_k: topK,
-        stop_sequences: stopSequences,
+        max_tokens: maxTokens,
+        ...(topP !== undefined ? { top_p: topP } : {}),
+        ...(stop !== undefined ? { stop_sequences: stop } : {}),
       };
 
-      // Add system message if present
-      if (systemMsg) {
-        request.system = systemMsg;
-      }
-
-      const result = await anthropic.messages.create(request);
+      console.log("[Anthropic] Calling Anthropic API...");
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": process.env.ANTHROPIC_API_KEY,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify(requestBody),
+      });
 
-      // Extract text content
-      const content = result.content[0].text;
+      if (!response.ok) {
+        const error = await response
+          .json()
+          .catch(() => ({ error: response.statusText }));
+        throw { status: response.status, ...error };
+      }
 
-      // Try to parse JSON if expected
-      let parsed = null;
-      if (responseFormat?.type === "json_object" || responseFormat === "json") {
-        parsed = tryParseJSON(content);
-        if (!parsed && attempt < maxRetries) {
-          lastError = new Error("Failed to parse JSON response");
-          continue;
-        }
+      const data = await response.json();
+      console.log("[Anthropic] Response received from Anthropic API");
+
+      // Extract text from response.content blocks
+      const blocks = Array.isArray(data?.content) ? data.content : [];
+      const text = blocks
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("");
+      console.log("[Anthropic] Response text length:", text.length);
+
+      // Parse JSON - this is required for all calls
+      const parsed = tryParseJSON(text);
+      if (!parsed) {
+        throw new ProviderJsonParseError(
+          "Anthropic",
+          model,
+          text.substring(0, 200),
+          "Failed to parse JSON response from Anthropic API"
+        );
       }
 
+      // Normalize usage (if provided)
+      const prompt_tokens = data?.usage?.input_tokens;
+      const completion_tokens = data?.usage?.output_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("[Anthropic] Returning response from Anthropic API");
       return {
-        content: parsed || content,
-        text: content,
-        usage: {
-          prompt_tokens: result.usage.input_tokens,
-          completion_tokens: result.usage.output_tokens,
-          total_tokens: result.usage.input_tokens + result.usage.output_tokens,
-          cache_read_input_tokens: result.usage.cache_creation_input_tokens,
-          cache_write_input_tokens: result.usage.cache_write_input_tokens,
-        },
-        raw: result,
+        content: parsed,
+        text,
+        ...(usage ? { usage } : {}),
+        raw: data,
       };
     } catch (error) {
       lastError = error;
+      const msg = error?.error?.message || error?.message || "";
+      console.error("[Anthropic] Error occurred:", msg);
+      console.error("[Anthropic] Error status:", error?.status);
 
       if (error.status === 401) throw error;
 
       if (isRetryableError(error) && attempt < maxRetries) {
+        console.log("[Anthropic] Retrying due to retryable error");
         continue;
       }
 

package/src/providers/base.js

@@ -69,3 +69,55 @@ export function tryParseJSON(text) {
     }
   }
 }
+
+/**
+ * Error thrown when JSON response format is required but not provided
+ */
+export class ProviderJsonModeError extends Error {
+  constructor(providerName, message) {
+    super(message);
+    this.name = "ProviderJsonModeError";
+    this.provider = providerName;
+  }
+}
+
+/**
+ * Error thrown when JSON parsing fails and should not be retried
+ */
+export class ProviderJsonParseError extends Error {
+  constructor(provider, model, sample, message = "Failed to parse JSON response") {
+    super(message);
+    this.name = "ProviderJsonParseError";
+    this.provider = provider;
+    this.model = model;
+    this.sample = sample;
+  }
+}
+
+/**
+ * Ensures that responseFormat is configured for JSON output
+ * @param {*} responseFormat - The response format object or string
+ * @param {string} providerName - Name of the provider for error reporting
+ * @throws {ProviderJsonModeError} When JSON format is not properly configured
+ */
+export function ensureJsonResponseFormat(responseFormat, providerName) {
+  if (!responseFormat) {
+    throw new ProviderJsonModeError(
+      providerName,
+      `${providerName} requires responseFormat to be set for JSON mode`
+    );
+  }
+
+  // Check for valid JSON format types
+  const isValidJsonFormat = 
+    responseFormat === "json" ||
+    responseFormat?.type === "json_object" ||
+    responseFormat?.type === "json_schema";
+
+  if (!isValidJsonFormat) {
+    throw new ProviderJsonModeError(
+      providerName,
+      `${providerName} only supports JSON response format. Got: ${JSON.stringify(responseFormat)}`
+    );
+  }
+}

package/src/providers/deepseek.js

@@ -3,6 +3,8 @@ import {
   isRetryableError,
   sleep,
   tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
 } from "./base.js";
 
 export async function deepseekChat({
@@ -10,13 +12,16 @@ export async function deepseekChat({
   model = "deepseek-chat",
   temperature = 0.7,
   maxTokens,
-  responseFormat = "json",
+  responseFormat,
   topP,
   frequencyPenalty,
   presencePenalty,
   stop,
   maxRetries = 3,
 }) {
+  // Enforce JSON mode - reject calls without proper JSON responseFormat
+  ensureJsonResponseFormat(responseFormat, "DeepSeek");
+
   if (!process.env.DEEPSEEK_API_KEY) {
     throw new Error("DeepSeek API key not configured");
   }
@@ -44,7 +49,7 @@ export async function deepseekChat({
         stop,
       };
 
-      // Add response format if needed
+      // Add response format - this is now required for all calls
       if (responseFormat?.type === "json_object" || responseFormat === "json") {
         requestBody.response_format = { type: "json_object" };
       }
@@ -71,23 +76,19 @@ export async function deepseekChat({
       const data = await response.json();
       const content = data.choices[0].message.content;
 
-      // Only try JSON parsing if responseFormat indicates JSON output
-      if (responseFormat?.type === "json_object" || responseFormat === "json") {
-        const parsed = tryParseJSON(content);
-        if (parsed === null && attempt < maxRetries) {
-          // JSON parsing failed, retry
-          lastError = new Error("Failed to parse JSON response");
-          continue;
-        }
-        return {
-          content: parsed,
-          usage: data.usage,
-          raw: data,
-        };
+      // Parse JSON - this is now required for all calls
+      const parsed = tryParseJSON(content);
+      if (!parsed) {
+        throw new ProviderJsonParseError(
+          "DeepSeek",
+          model,
+          content.substring(0, 200),
+          "Failed to parse JSON response from DeepSeek API"
+        );
       }
 
       return {
-        content,
+        content: parsed,
         usage: data.usage,
         raw: data,
       };
@@ -106,21 +107,3 @@ export async function deepseekChat({
 
   throw lastError || new Error(`Failed after ${maxRetries + 1} attempts`);
 }
-
-// Keep backward compatibility
-export async function queryDeepSeek(
-  system,
-  prompt,
-  model = "deepseek-reasoner"
-) {
-  const response = await deepseekChat({
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: prompt },
-    ],
-    model,
-    responseFormat: "json",
-  });
-
-  return response.content;
-}

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;
+}