@defai.digital/automatosx 6.2.1 → 6.2.5

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [6.2.5] - 2025-10-31
+
+### 🔧 Fixes
+
+**Routing and Cost Estimation Bugs (Bugs #31, #32)**
+
+Through heavy-thinking analysis and ax agent collaboration, identified and fixed 2 critical bugs in routing systems:
+
+- **Bug #31 (MEDIUM)**: Division by zero in routing statistics (`src/core/routing-strategy.ts:317`)
+  - **Problem**: Empty scores array caused `0/0 = NaN` in avgScores calculation
+  - **Impact**: Corrupted routing statistics with NaN values
+  - **Fix**: Added guard to check `scores.length === 0` before division, return 0 for empty arrays
+  - **Pattern**: Same defensive approach as Bugs #16, #19
+
+- **Bug #32 (HIGH)**: Unsafe metadata access crashes cost estimation (`src/core/router.ts:878-880`)
+  - **Problem**: Accessed `metadata.costPerToken.input/output` without validation
+  - **Impact**: TypeError crash if provider metadata missing `costPerToken` field
+  - **Fix**: Added comprehensive validation of metadata structure before access
+  - **Fallback**: Uses fallback pricing ($2.50/$10.00 per 1M tokens) if metadata invalid
+  - **Pattern**: Defensive programming to prevent production crashes
+
+### 📊 Impact
+
+- **Users affected**: All users using multi-factor routing and cost tracking
+- **Breaking changes**: None
+- **Migration**: None required - automatic graceful fallback for missing metadata
+
+### ✅ Testing
+
+- All 2,281 unit tests passing
+- TypeScript compilation successful
+- Build successful
+
 ## [6.0.7] - 2025-10-30
 
 ### 🔧 Fixes

package/README.md

@@ -7,7 +7,7 @@ AutomatosX is the only AI CLI that combines declarative workflow specs, policy-d
 [![npm version](https://img.shields.io/npm/v/@defai.digital/automatosx.svg)](https://www.npmjs.com/package/@defai.digital/automatosx)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-100%25-blue.svg)](https://www.typescriptlang.org/)
-[![Tests](https://img.shields.io/badge/tests-2,457%20passing-brightgreen.svg)](#)
+[![Tests](https://img.shields.io/badge/tests-2,468%20passing-brightgreen.svg)](#)
 [![macOS](https://img.shields.io/badge/macOS-26.0-blue.svg)](https://www.apple.com/macos)
 [![Windows](https://img.shields.io/badge/Windows-10+-blue.svg)](https://www.microsoft.com/windows)
 [![Ubuntu](https://img.shields.io/badge/Ubuntu-24.04-orange.svg)](https://ubuntu.com)

package/dist/index.js

@@ -6364,12 +6364,16 @@ var init_openai_sdk_provider = __esm({
     init_provider_connection_pool();
     init_provider_limit_manager();
     init_streaming_feedback();
+    init_timeout_estimator();
     OpenAISDKProvider = class extends BaseProvider {
       sdkConfig;
       connectionPool = getProviderConnectionPool();
       initialized = false;
       // v6.0.7: Streaming feedback
       currentStreamingFeedback = null;
+      // v6.2.2: Progress tracking for SDK streaming (bugfix #5, #6)
+      currentProgressTracker = null;
+      progressInterval = null;
       constructor(config, sdkConfig = {}) {
         super(config);
         this.sdkConfig = sdkConfig;
@@ -6437,10 +6441,25 @@ var init_openai_sdk_provider = __esm({
        */
       async executeRequest(request) {
         const startTime = Date.now();
+        const fullPrompt = `${request.systemPrompt || ""}
+${request.prompt}`.trim();
+        const timeoutEstimate = estimateTimeout({
+          prompt: fullPrompt,
+          systemPrompt: request.systemPrompt,
+          model: typeof request.model === "string" ? request.model : void 0,
+          maxTokens: request.maxTokens
+        });
+        if (process.env.AUTOMATOSX_QUIET !== "true") {
+          logger.info(formatTimeoutEstimate(timeoutEstimate));
+        }
+        if (timeoutEstimate.estimatedDurationMs > 1e4) {
+          this.startProgressTracking(timeoutEstimate.estimatedDurationMs);
+        }
         const useMock = process.env.AUTOMATOSX_MOCK_PROVIDERS === "true" || process.env.NODE_ENV === "test" || process.env.VITEST === "true";
         if (useMock) {
           const mockPrompt = request.prompt.substring(0, 100);
           const latency = Date.now() - startTime;
+          this.stopProgressTracking();
           return {
             content: `[Mock Response from OpenAI SDK]
 
@@ -6477,6 +6496,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
               // Non-streaming for this method
             });
             await this.connectionPool.release(this.config.name, connection);
+            this.stopProgressTracking();
             const content = response.choices[0]?.message?.content || "";
             const finishReason = this.mapFinishReason(response.choices[0]?.finish_reason);
             const latency = Date.now() - startTime;
@@ -6500,9 +6520,11 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
             };
           } catch (error) {
             await this.connectionPool.release(this.config.name, connection);
+            this.stopProgressTracking();
             throw error;
           }
         } catch (error) {
+          this.stopProgressTracking();
           return this.handleSDKError(error, request, startTime);
         }
       }
@@ -6511,6 +6533,20 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        */
       async executeStreaming(request, options) {
         const startTime = Date.now();
+        const fullPrompt = `${request.systemPrompt || ""}
+${request.prompt}`.trim();
+        const timeoutEstimate = estimateTimeout({
+          prompt: fullPrompt,
+          systemPrompt: request.systemPrompt,
+          model: typeof request.model === "string" ? request.model : void 0,
+          maxTokens: request.maxTokens
+        });
+        if (process.env.AUTOMATOSX_QUIET !== "true") {
+          logger.info(formatTimeoutEstimate(timeoutEstimate));
+        }
+        if (timeoutEstimate.estimatedDurationMs > 1e4) {
+          this.startProgressTracking(timeoutEstimate.estimatedDurationMs);
+        }
         const estimatedOutputTokens = request.maxTokens || this.estimateTokens(request.prompt) * 2;
         this.currentStreamingFeedback = createStreamingFeedback(estimatedOutputTokens);
         const useMock = process.env.AUTOMATOSX_MOCK_PROVIDERS === "true" || process.env.NODE_ENV === "test" || process.env.VITEST === "true";
@@ -6531,6 +6567,7 @@ This is a placeholder streaming response. Set AUTOMATOSX_MOCK_PROVIDERS=false to
             this.currentStreamingFeedback.stop(50);
             this.currentStreamingFeedback = null;
           }
+          this.stopProgressTracking();
           return {
             content: mockContent,
             model: request.model || "gpt-4o",
@@ -6586,6 +6623,19 @@ This is a placeholder streaming response. Set AUTOMATOSX_MOCK_PROVIDERS=false to
                     });
                   }
                 }
+                if (options.onProgress) {
+                  try {
+                    const currentTokens = this.estimateTokens(fullContent);
+                    const expectedTokens = request.maxTokens || 4096;
+                    const progress = Math.min(currentTokens / expectedTokens, 0.95);
+                    options.onProgress(progress);
+                  } catch (error) {
+                    logger.warn("Streaming onProgress callback error", {
+                      provider: this.config.name,
+                      error: error instanceof Error ? error.message : String(error)
+                    });
+                  }
+                }
               }
               if (chunk.choices[0]?.finish_reason) {
                 finishReason = this.mapFinishReason(chunk.choices[0].finish_reason);
@@ -6616,6 +6666,17 @@ This is a placeholder streaming response. Set AUTOMATOSX_MOCK_PROVIDERS=false to
               this.currentStreamingFeedback.stop(completionTokens);
               this.currentStreamingFeedback = null;
             }
+            if (options.onProgress) {
+              try {
+                options.onProgress(1);
+              } catch (error) {
+                logger.warn("Final streaming onProgress callback error", {
+                  provider: this.config.name,
+                  error: error instanceof Error ? error.message : String(error)
+                });
+              }
+            }
+            this.stopProgressTracking();
             return {
               content: fullContent,
               model: modelUsed,
@@ -6633,6 +6694,7 @@ This is a placeholder streaming response. Set AUTOMATOSX_MOCK_PROVIDERS=false to
               this.currentStreamingFeedback.stop();
               this.currentStreamingFeedback = null;
             }
+            this.stopProgressTracking();
             throw error;
           }
         } catch (error) {
@@ -6640,6 +6702,7 @@ This is a placeholder streaming response. Set AUTOMATOSX_MOCK_PROVIDERS=false to
             this.currentStreamingFeedback.stop();
             this.currentStreamingFeedback = null;
           }
+          this.stopProgressTracking();
           return this.handleSDKError(error, request, startTime);
         }
       }
@@ -6808,6 +6871,38 @@ This is a placeholder streaming response. Set AUTOMATOSX_MOCK_PROVIDERS=false to
           tokensUsed: inputTokens + outputTokens
         };
       }
+      /**
+       * Start progress tracking for long operations
+       * v6.2.2: Consistency with CLI providers (bugfix #5, #6)
+       * @param estimatedDurationMs - Estimated duration in milliseconds
+       */
+      startProgressTracking(estimatedDurationMs) {
+        if (process.env.AUTOMATOSX_QUIET === "true") {
+          return;
+        }
+        this.currentProgressTracker = new ProgressTracker(estimatedDurationMs);
+        this.progressInterval = setInterval(() => {
+          if (this.currentProgressTracker && this.currentProgressTracker.shouldUpdate()) {
+            process.stderr.write("\r" + this.currentProgressTracker.formatProgress());
+          }
+        }, 1e3);
+      }
+      /**
+       * Stop progress tracking
+       * v6.2.2: Consistency with CLI providers (bugfix #5, #6)
+       */
+      stopProgressTracking() {
+        if (this.progressInterval) {
+          clearInterval(this.progressInterval);
+          this.progressInterval = null;
+        }
+        if (this.currentProgressTracker) {
+          if (process.env.AUTOMATOSX_QUIET !== "true") {
+            process.stderr.write("\r" + " ".repeat(80) + "\r");
+          }
+          this.currentProgressTracker = null;
+        }
+      }
     };
   }
 });
@@ -11702,6 +11797,30 @@ var ProviderMetricsTracker = class extends EventEmitter {
    * Record a request for metrics tracking
    */
   async recordRequest(provider, latencyMs, success, finishReason, tokenUsage, costUsd, model) {
+    if (!provider || provider.trim().length === 0) {
+      throw new Error("Provider name cannot be empty");
+    }
+    if (!Number.isFinite(latencyMs)) {
+      throw new Error(`Invalid latencyMs value: ${latencyMs}. Must be a finite number.`);
+    }
+    if (latencyMs < 0) {
+      throw new Error(`Invalid latencyMs value: ${latencyMs}. Cannot be negative.`);
+    }
+    if (!Number.isFinite(costUsd)) {
+      throw new Error(`Invalid costUsd value: ${costUsd}. Must be a finite number.`);
+    }
+    if (costUsd < 0) {
+      throw new Error(`Invalid costUsd value: ${costUsd}. Cannot be negative.`);
+    }
+    if (!Number.isFinite(tokenUsage.prompt) || tokenUsage.prompt < 0) {
+      throw new Error(`Invalid prompt tokens: ${tokenUsage.prompt}. Must be a non-negative finite number.`);
+    }
+    if (!Number.isFinite(tokenUsage.completion) || tokenUsage.completion < 0) {
+      throw new Error(`Invalid completion tokens: ${tokenUsage.completion}. Must be a non-negative finite number.`);
+    }
+    if (!Number.isFinite(tokenUsage.total) || tokenUsage.total < 0) {
+      throw new Error(`Invalid total tokens: ${tokenUsage.total}. Must be a non-negative finite number.`);
+    }
     if (!this.metrics.has(provider)) {
       this.metrics.set(provider, []);
     }
@@ -12181,6 +12300,10 @@ var RoutingStrategyManager = class extends EventEmitter {
       }
     }
     for (const [provider, scores] of Object.entries(scoresByProvider)) {
+      if (scores.length === 0) {
+        stats.avgScores[provider] = 0;
+        continue;
+      }
       const avg = scores.reduce((sum, s) => sum + s, 0) / scores.length;
       stats.avgScores[provider] = avg;
     }
@@ -12986,49 +13109,91 @@ var CostTracker = class extends EventEmitter {
   }
   /**
    * Initialize database
+   * v6.2.4: Bug fix #24 - Wrap in try-catch to prevent memory leaks on error
    */
   async initialize() {
     if (this.initialized) {
       return;
     }
-    const dir = dirname(this.dbPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database3(this.dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS cost_entries (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        timestamp INTEGER NOT NULL,
-        provider TEXT NOT NULL,
-        model TEXT NOT NULL,
-        session_id TEXT,
-        agent TEXT,
-        prompt_tokens INTEGER NOT NULL,
-        completion_tokens INTEGER NOT NULL,
-        total_tokens INTEGER NOT NULL,
-        estimated_cost_usd REAL NOT NULL,
-        request_id TEXT
-      );
+    try {
+      const dir = dirname(this.dbPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      this.db = new Database3(this.dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS cost_entries (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp INTEGER NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT NOT NULL,
+          session_id TEXT,
+          agent TEXT,
+          prompt_tokens INTEGER NOT NULL,
+          completion_tokens INTEGER NOT NULL,
+          total_tokens INTEGER NOT NULL,
+          estimated_cost_usd REAL NOT NULL,
+          request_id TEXT
+        );
 
-      CREATE INDEX IF NOT EXISTS idx_cost_timestamp ON cost_entries(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_cost_provider ON cost_entries(provider);
-      CREATE INDEX IF NOT EXISTS idx_cost_session ON cost_entries(session_id);
-      CREATE INDEX IF NOT EXISTS idx_cost_agent ON cost_entries(agent);
-    `);
-    this.initialized = true;
-    logger.info("CostTracker initialized", {
-      dbPath: this.dbPath
-    });
+        CREATE INDEX IF NOT EXISTS idx_cost_timestamp ON cost_entries(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_cost_provider ON cost_entries(provider);
+        CREATE INDEX IF NOT EXISTS idx_cost_session ON cost_entries(session_id);
+        CREATE INDEX IF NOT EXISTS idx_cost_agent ON cost_entries(agent);
+      `);
+      this.initialized = true;
+      logger.info("CostTracker initialized", {
+        dbPath: this.dbPath
+      });
+    } catch (error) {
+      if (this.db) {
+        try {
+          this.db.close();
+        } catch (closeError) {
+        }
+        this.db = null;
+      }
+      this.initialized = false;
+      logger.error("Failed to initialize CostTracker", {
+        error: error instanceof Error ? error.message : String(error),
+        dbPath: this.dbPath
+      });
+      throw error;
+    }
   }
   /**
    * Record cost for a request
+   * v6.2.4: Bug fix #25 - Added input validation
    */
   async recordCost(entry) {
     if (!this.initialized) {
       await this.initialize();
     }
+    if (!entry.provider || entry.provider.trim().length === 0) {
+      throw new Error("Provider name cannot be empty");
+    }
+    if (!entry.model || entry.model.trim().length === 0) {
+      throw new Error("Model name cannot be empty");
+    }
+    if (!Number.isFinite(entry.estimatedCostUsd)) {
+      throw new Error(`Invalid estimatedCostUsd value: ${entry.estimatedCostUsd}. Must be a finite number.`);
+    }
+    if (entry.estimatedCostUsd < 0) {
+      throw new Error(`Invalid estimatedCostUsd value: ${entry.estimatedCostUsd}. Cannot be negative.`);
+    }
+    if (!Number.isFinite(entry.promptTokens) || entry.promptTokens < 0) {
+      throw new Error(`Invalid promptTokens: ${entry.promptTokens}. Must be a non-negative finite number.`);
+    }
+    if (!Number.isFinite(entry.completionTokens) || entry.completionTokens < 0) {
+      throw new Error(`Invalid completionTokens: ${entry.completionTokens}. Must be a non-negative finite number.`);
+    }
+    if (!Number.isFinite(entry.totalTokens) || entry.totalTokens < 0) {
+      throw new Error(`Invalid totalTokens: ${entry.totalTokens}. Must be a non-negative finite number.`);
+    }
+    if (!Number.isFinite(entry.timestamp) || entry.timestamp <= 0) {
+      throw new Error(`Invalid timestamp: ${entry.timestamp}. Must be a positive finite number.`);
+    }
     const stmt = this.db.prepare(`
       INSERT INTO cost_entries (
         timestamp, provider, model, session_id, agent,
@@ -14186,8 +14351,8 @@ var Router = class {
    */
   estimateCost(providerName, tokensUsed) {
     const metadata = PROVIDER_METADATA[providerName];
-    if (!metadata) {
-      logger.warn(`Provider metadata not found for cost estimation: ${providerName}, using fallback costs`);
+    if (!metadata || !metadata.costPerToken || typeof metadata.costPerToken.input !== "number" || typeof metadata.costPerToken.output !== "number") {
+      logger.warn(`Provider metadata or cost data not found for: ${providerName}, using fallback costs`);
       const inputCostPer1M = 2.5;
       const outputCostPer1M = 10;
       const inputCost2 = tokensUsed.prompt / 1e6 * inputCostPer1M;
@@ -14283,6 +14448,7 @@ var MemoryManager = class _MemoryManager {
    * Initialize database and load FTS5 extension
    *
    * v4.11.0: Added FTS5 full-text search support
+   * v6.2.4: Bug fix #30 - Wrap in try-catch to prevent memory leaks on error
    */
   async initialize() {
     if (this.initialized) return;
@@ -14380,6 +14546,15 @@ var MemoryManager = class _MemoryManager {
         entryCount: this.entryCount
       });
     } catch (error) {
+      if (this.db) {
+        try {
+          this.db.close();
+        } catch (closeError) {
+        }
+        this.initialized = false;
+        this.entryCount = 0;
+        this.statements = {};
+      }
       logger.error("Failed to initialize MemoryManager", { error: error.message });
       throw new MemoryError(
         `Failed to initialize memory system: ${error.message}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "6.2.1",
+  "version": "6.2.5",
   "description": "AI Agent Orchestration Platform",
   "type": "module",
   "publishConfig": {