@iservu-inc/adf-cli 0.12.0 → 0.12.10

package/lib/ai/ai-client.js

@@ -97,8 +97,19 @@ class AIClient {
       ]
     });
 
+    // Validate response structure
+    if (!response.content || response.content.length === 0) {
+      throw new Error(`Anthropic model '${this.model}' returned no content.`);
+    }
+
+    const content = response.content[0].text;
+
+    if (!content || content.trim().length === 0) {
+      throw new Error(`Anthropic model '${this.model}' returned empty text.`);
+    }
+
     return {
-      content: response.content[0].text,
+      content,
       model: this.model,
       provider: 'anthropic',
       usage: {
@@ -113,9 +124,9 @@ class AIClient {
    * OpenAI GPT request
    */
   async openaiRequest(prompt, maxTokens, temperature) {
-    // o-series models (o1, o3, etc.) use max_completion_tokens instead of max_tokens
-    // Check for any model starting with 'o' followed by a digit
-    const isOSeriesModel = /^o\d/.test(this.model);
+    // Newer OpenAI models use max_completion_tokens instead of max_tokens
+    // This includes: o-series (o1, o3), gpt-5 series, and potentially others
+    const usesNewParameters = /^(o1|o3|gpt-5)/i.test(this.model);
 
     const requestParams = {
       model: this.model,
@@ -127,27 +138,56 @@ class AIClient {
       ]
     };
 
-    // o-series models use different parameter names
-    if (isOSeriesModel) {
+    // Newer models use different parameter names
+    if (usesNewParameters) {
       requestParams.max_completion_tokens = maxTokens;
-      // o-series models don't support temperature parameter
+      // Newer reasoning models don't support temperature parameter
     } else {
       requestParams.max_tokens = maxTokens;
       requestParams.temperature = temperature;
     }
 
-    const response = await this.client.chat.completions.create(requestParams);
+    try {
+      const response = await this.client.chat.completions.create(requestParams);
 
-    return {
-      content: response.choices[0].message.content,
-      model: this.model,
-      provider: 'openai',
-      usage: {
-        promptTokens: response.usage.prompt_tokens,
-        completionTokens: response.usage.completion_tokens,
-        totalTokens: response.usage.total_tokens
+      return {
+        content: response.choices[0].message.content,
+        model: this.model,
+        provider: 'openai',
+        usage: {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        }
+      };
+    } catch (error) {
+      // If we get a 400 error about max_tokens not being supported,
+      // automatically retry with max_completion_tokens
+      if (error.status === 400 && error.message.includes('max_tokens')) {
+        const retryParams = {
+          model: this.model,
+          messages: requestParams.messages,
+          max_completion_tokens: maxTokens
+          // Don't include temperature for new parameter format models
+        };
+
+        const response = await this.client.chat.completions.create(retryParams);
+
+        return {
+          content: response.choices[0].message.content,
+          model: this.model,
+          provider: 'openai',
+          usage: {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens
+          }
+        };
       }
-    };
+
+      // Re-throw other errors
+      throw error;
+    }
   }
 
   /**
@@ -165,8 +205,20 @@ class AIClient {
     const result = await model.generateContent(prompt);
     const response = result.response;
 
+    // Validate response
+    let content;
+    try {
+      content = response.text();
+    } catch (error) {
+      throw new Error(`Google Gemini model '${this.model}' failed to generate text: ${error.message}`);
+    }
+
+    if (!content || content.trim().length === 0) {
+      throw new Error(`Google Gemini model '${this.model}' returned empty content.`);
+    }
+
     return {
-      content: response.text(),
+      content,
       model: this.model,
       provider: 'google',
       usage: {
@@ -181,28 +233,85 @@ class AIClient {
    * OpenRouter request (uses OpenAI-compatible API)
    */
   async openrouterRequest(prompt, maxTokens, temperature) {
-    const response = await this.client.chat.completions.create({
+    // Newer OpenAI models on OpenRouter may use max_completion_tokens
+    // This includes: o-series (o1, o3), gpt-5 series
+    const usesNewParameters = /^openai\/(o1|o3|gpt-5)/i.test(this.model);
+
+    const requestParams = {
       model: this.model,
-      max_tokens: maxTokens,
-      temperature,
       messages: [
         {
           role: 'user',
           content: prompt
         }
       ]
-    });
+    };
 
-    return {
-      content: response.choices[0].message.content,
-      model: this.model,
-      provider: 'openrouter',
-      usage: {
-        promptTokens: response.usage?.prompt_tokens || 0,
-        completionTokens: response.usage?.completion_tokens || 0,
-        totalTokens: response.usage?.total_tokens || 0
+    // Newer models use different parameter names
+    if (usesNewParameters) {
+      requestParams.max_completion_tokens = maxTokens;
+      // Newer reasoning models don't support temperature parameter
+    } else {
+      requestParams.max_tokens = maxTokens;
+      requestParams.temperature = temperature;
+    }
+
+    try {
+      const response = await this.client.chat.completions.create(requestParams);
+
+      // Validate response structure
+      if (!response.choices || response.choices.length === 0) {
+        throw new Error(`OpenRouter model '${this.model}' returned no choices. The model may not exist or be unavailable.`);
       }
-    };
+
+      if (!response.choices[0].message) {
+        throw new Error(`OpenRouter model '${this.model}' returned invalid response structure.`);
+      }
+
+      const content = response.choices[0].message.content;
+
+      if (!content || content.trim().length === 0) {
+        throw new Error(`OpenRouter model '${this.model}' returned empty content. The model may not support this request format.`);
+      }
+
+      return {
+        content,
+        model: this.model,
+        provider: 'openrouter',
+        usage: {
+          promptTokens: response.usage?.prompt_tokens || 0,
+          completionTokens: response.usage?.completion_tokens || 0,
+          totalTokens: response.usage?.total_tokens || 0
+        }
+      };
+    } catch (error) {
+      // If we get a 400 error about max_tokens not being supported,
+      // automatically retry with max_completion_tokens
+      if (error.status === 400 && error.message.includes('max_tokens')) {
+        const retryParams = {
+          model: this.model,
+          messages: requestParams.messages,
+          max_completion_tokens: maxTokens
+          // Don't include temperature for new parameter format models
+        };
+
+        const response = await this.client.chat.completions.create(retryParams);
+
+        return {
+          content: response.choices[0].message.content,
+          model: this.model,
+          provider: 'openrouter',
+          usage: {
+            promptTokens: response.usage?.prompt_tokens || 0,
+            completionTokens: response.usage?.completion_tokens || 0,
+            totalTokens: response.usage?.total_tokens || 0
+          }
+        };
+      }
+
+      // Re-throw other errors
+      throw error;
+    }
   }
 
   /**
@@ -211,21 +320,29 @@ class AIClient {
   async test() {
     const testPrompt = 'Respond with exactly: "Connection successful"';
 
-    const response = await this.sendMessage(testPrompt, {
-      maxTokens: 50,
-      temperature: 0
-    });
+    try {
+      const response = await this.sendMessage(testPrompt, {
+        maxTokens: 50,
+        temperature: 0
+      });
 
-    if (!response.content) {
-      throw new Error('No response from AI provider');
-    }
+      if (!response.content) {
+        throw new Error(`Model '${this.model}' on ${this.provider} returned no content. The model may not exist or be unavailable.`);
+      }
 
-    return {
-      success: true,
-      provider: this.provider,
-      model: this.model,
-      response: response.content
-    };
+      return {
+        success: true,
+        provider: this.provider,
+        model: this.model,
+        response: response.content
+      };
+    } catch (error) {
+      // Add context to the error message
+      if (error.message.includes('returned no content') || error.message.includes('returned no choices')) {
+        throw error; // Already has good context
+      }
+      throw new Error(`Test failed for ${this.provider} model '${this.model}': ${error.message}`);
+    }
   }
 
   /**