fix(ai): Correctly imports generateText in openai.js, adds specific cause and reason for OpenRouter failures in the openrouter.js catch, performs complexity analysis on all tm tasks, adds new tasks to further improve the maxTokens to take input and output maximum into account. Adjusts default fallback max tokens so 3.5 does not fail.

2025-05-17 18:42:57 -04:00
parent 8a3b611fc2
commit 026815353f
12 changed files with 1364 additions and 304 deletions
--- a/tasks/task_087.txt
+++ b/tasks/task_087.txt
@@ -0,0 +1,119 @@
+# Task ID: 87
+# Title: Implement validation and error handling
+# Status: pending
+# Dependencies: 85
+# Priority: low
+# Description: Add comprehensive validation and error handling for token limits throughout the system, including helpful error messages and graceful fallbacks.
+# Details:
+1. Add validation when loading models in `config-manager.js`:
+```javascript
+function _validateModelMap(modelMap) {
+  // Validate each provider's models
+  Object.entries(modelMap).forEach(([provider, models]) => {
+    models.forEach(model => {
+      // Check for required token limit fields
+      if (!model.contextWindowTokens) {
+        console.warn(`Warning: Model ${model.id} from ${provider} is missing contextWindowTokens field`);
+      }
+      if (!model.maxOutputTokens) {
+        console.warn(`Warning: Model ${model.id} from ${provider} is missing maxOutputTokens field`);
+      }
+    });
+  });
+  return modelMap;
+}
+```
+
+2. Add validation when setting up a model in the CLI:
+```javascript
+function validateModelConfig(modelConfig, modelCapabilities) {
+  const issues = [];
+  
+  // Check if input tokens exceed model's context window
+  if (modelConfig.maxInputTokens > modelCapabilities.contextWindowTokens) {
+    issues.push(`maxInputTokens (${modelConfig.maxInputTokens}) exceeds model's context window (${modelCapabilities.contextWindowTokens})`);
+  }
+  
+  // Check if output tokens exceed model's maximum
+  if (modelConfig.maxOutputTokens > modelCapabilities.maxOutputTokens) {
+    issues.push(`maxOutputTokens (${modelConfig.maxOutputTokens}) exceeds model's maximum output tokens (${modelCapabilities.maxOutputTokens})`);
+  }
+  
+  // Check if combined tokens exceed context window
+  if (modelConfig.maxInputTokens + modelConfig.maxOutputTokens > modelCapabilities.contextWindowTokens) {
+    issues.push(`Combined maxInputTokens and maxOutputTokens (${modelConfig.maxInputTokens + modelConfig.maxOutputTokens}) exceeds model's context window (${modelCapabilities.contextWindowTokens})`);
+  }
+  
+  return issues;
+}
+```
+
+3. Add graceful fallbacks in `ai-services-unified.js`:
+```javascript
+// Fallback for missing token limits
+if (!roleParams.maxInputTokens) {
+  console.warn(`Warning: maxInputTokens not specified for role '${currentRole}'. Using default value.`);
+  roleParams.maxInputTokens = 8000; // Reasonable default
+}
+
+if (!roleParams.maxOutputTokens) {
+  console.warn(`Warning: maxOutputTokens not specified for role '${currentRole}'. Using default value.`);
+  roleParams.maxOutputTokens = 2000; // Reasonable default
+}
+
+// Fallback for missing model capabilities
+if (!modelCapabilities.contextWindowTokens) {
+  console.warn(`Warning: contextWindowTokens not specified for model ${modelId}. Using conservative estimate.`);
+  modelCapabilities.contextWindowTokens = roleParams.maxInputTokens + roleParams.maxOutputTokens;
+}
+
+if (!modelCapabilities.maxOutputTokens) {
+  console.warn(`Warning: maxOutputTokens not specified for model ${modelId}. Using role configuration.`);
+  modelCapabilities.maxOutputTokens = roleParams.maxOutputTokens;
+}
+```
+
+4. Add detailed logging for token usage:
+```javascript
+function logTokenUsage(provider, modelId, inputTokens, outputTokens, role) {
+  const inputCost = calculateTokenCost(provider, modelId, 'input', inputTokens);
+  const outputCost = calculateTokenCost(provider, modelId, 'output', outputTokens);
+  
+  console.info(`Token usage for ${role} role with ${provider}/${modelId}:`);
+  console.info(`- Input: ${inputTokens.toLocaleString()} tokens ($${inputCost.toFixed(6)})`);
+  console.info(`- Output: ${outputTokens.toLocaleString()} tokens ($${outputCost.toFixed(6)})`);
+  console.info(`- Total cost: $${(inputCost + outputCost).toFixed(6)}`);
+  console.info(`- Available output tokens: ${availableOutputTokens.toLocaleString()}`);
+}
+```
+
+5. Add a helper function to suggest configuration improvements:
+```javascript
+function suggestTokenConfigImprovements(roleParams, modelCapabilities, promptTokens) {
+  const suggestions = [];
+  
+  // If prompt is using less than 50% of allowed input
+  if (promptTokens < roleParams.maxInputTokens * 0.5) {
+    suggestions.push(`Consider reducing maxInputTokens from ${roleParams.maxInputTokens} to save on potential costs`);
+  }
+  
+  // If output tokens are very limited due to large input
+  const availableOutput = Math.min(
+    roleParams.maxOutputTokens,
+    modelCapabilities.contextWindowTokens - promptTokens
+  );
+  
+  if (availableOutput < roleParams.maxOutputTokens * 0.5) {
+    suggestions.push(`Available output tokens (${availableOutput}) are significantly less than configured maxOutputTokens (${roleParams.maxOutputTokens}) due to large input`);
+  }
+  
+  return suggestions;
+}
+```
+
+# Test Strategy:
+1. Test validation functions with valid and invalid configurations
+2. Verify fallback behavior works correctly when configuration is missing
+3. Test error messages are clear and actionable
+4. Test logging functions provide useful information
+5. Verify suggestion logic provides helpful recommendations