@haoyiyin/workflow 0.2.2 → 0.2.3

package/src/agents/dispatcher-enhanced.ts

@@ -0,0 +1,350 @@
+/**
+ * Enhanced subagent dispatcher with resilience and token budget
+ */
+import { spawn } from 'child_process'
+import { TokenBudget, BudgetExceededError } from './token-budget.js'
+import type { SubagentConfig, SubagentContract, SubagentResult, PermissionSet } from './types.js'
+
+// Circuit breaker states
+enum CircuitState {
+  CLOSED = 'closed',
+  OPEN = 'open',
+  HALF_OPEN = 'half-open'
+}
+
+// Circuit breaker configuration
+interface CircuitBreakerConfig {
+  failureThreshold: number
+  successThreshold: number
+  timeout: number
+}
+
+// Retry policy configuration
+interface RetryPolicyConfig {
+  maxRetries: number
+  baseDelay: number
+  maxDelay: number
+  backoffMultiplier: number
+  retryableErrors: string[]
+}
+
+// Circuit breaker implementation
+class CircuitBreaker {
+  private state: CircuitState = CircuitState.CLOSED
+  private failureCount: number = 0
+  private successCount: number = 0
+  private nextAttempt: number = 0
+
+  constructor(private config: CircuitBreakerConfig) {}
+
+  async execute<T>(operation: () => Promise<T>, fallback?: () => T | undefined): Promise<T> {
+    if (this.state === CircuitState.OPEN) {
+      if (Date.now() < this.nextAttempt) {
+        if (fallback) {
+          console.log('[CircuitBreaker] Using fallback')
+          const result = fallback()
+          if (result !== undefined) return result as T
+        }
+        throw new Error(`Circuit OPEN. Retry after ${new Date(this.nextAttempt).toISOString()}`)
+      }
+      this.state = CircuitState.HALF_OPEN
+      console.log('[CircuitBreaker] Entering HALF_OPEN state')
+    }
+
+    try {
+      const result = await operation()
+      this.onSuccess()
+      return result
+    } catch (error) {
+      this.onFailure()
+      throw error
+    }
+  }
+
+  private onSuccess(): void {
+    this.failureCount = 0
+    if (this.state === CircuitState.HALF_OPEN) {
+      this.successCount++
+      if (this.successCount >= this.config.successThreshold) {
+        console.log('[CircuitBreaker] CLOSED - service recovered')
+        this.state = CircuitState.CLOSED
+        this.successCount = 0
+      }
+    }
+  }
+
+  private onFailure(): void {
+    this.failureCount++
+    if (this.state === CircuitState.HALF_OPEN || this.failureCount >= this.config.failureThreshold) {
+      console.log(`[CircuitBreaker] OPEN - failures: ${this.failureCount}`)
+      this.state = CircuitState.OPEN
+      this.nextAttempt = Date.now() + this.config.timeout
+      this.successCount = 0
+    }
+  }
+
+  getState(): CircuitState {
+    return this.state
+  }
+}
+
+// Retry policy implementation
+class RetryPolicy {
+  constructor(private config: RetryPolicyConfig) {}
+
+  async execute<T>(operation: () => Promise<T>): Promise<T> {
+    let lastError: Error | undefined
+
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      try {
+        return await operation()
+      } catch (error) {
+        lastError = error as Error
+        if (!this.isRetryable(error)) throw error
+        if (attempt < this.config.maxRetries) {
+          const delay = this.calculateDelay(attempt)
+          console.log(`[RetryPolicy] Attempt ${attempt + 1} failed, retrying in ${Math.round(delay)}ms`)
+          await this.sleep(delay)
+        }
+      }
+    }
+
+    throw new Error(`Failed after ${this.config.maxRetries} retries: ${lastError?.message}`)
+  }
+
+  private isRetryable(error: unknown): boolean {
+    if (!(error instanceof Error)) return false
+    const errorName = error.constructor.name
+    return this.config.retryableErrors.some(re =>
+      errorName.includes(re) || error.message.includes(re)
+    )
+  }
+
+  private calculateDelay(attempt: number): number {
+    const exponentialDelay = this.config.baseDelay * Math.pow(this.config.backoffMultiplier, attempt)
+    const jitter = exponentialDelay * 0.25 * (Math.random() * 2 - 1)
+    return Math.min(exponentialDelay + jitter, this.config.maxDelay)
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+}
+
+// Resilient dispatcher combining circuit breaker and retry
+export class ResilientDispatcher {
+  private circuitBreaker: CircuitBreaker
+  private retryPolicy: RetryPolicy
+  private tokenBudget: TokenBudget
+
+  constructor(
+    circuitConfig?: Partial<CircuitBreakerConfig>,
+    retryConfig?: Partial<RetryPolicyConfig>
+  ) {
+    this.circuitBreaker = new CircuitBreaker({
+      failureThreshold: 5,
+      successThreshold: 3,
+      timeout: 60000,
+      ...circuitConfig
+    })
+    this.retryPolicy = new RetryPolicy({
+      maxRetries: 3,
+      baseDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      retryableErrors: ['RateLimitError', 'TimeoutError', 'NetworkError', 'ECONNREFUSED'],
+      ...retryConfig
+    })
+    this.tokenBudget = new TokenBudget()
+  }
+
+  /**
+   * Dispatch a subagent with resilience
+   */
+  async dispatch<T>(
+    config: SubagentConfig,
+    contract: SubagentContract,
+    options?: {
+      fallback?: () => T
+      onRetry?: (attempt: number, error: Error) => void
+    }
+  ): Promise<T> {
+    // Check token budget
+    const estimatedTokens = TokenBudget.estimateTokens(contract.prompt)
+    if (!this.tokenBudget.canAfford(estimatedTokens)) {
+      throw new BudgetExceededError()
+    }
+
+    return this.circuitBreaker.execute(
+      async () => {
+        return await this.retryPolicy.execute(async () => {
+          const result = await this.spawnSubagent(config, contract)
+          this.tokenBudget.recordUsage(result.tokensUsed || estimatedTokens)
+          return this.parseResult<T>(result, contract)
+        })
+      },
+      options?.fallback
+    )
+  }
+
+  /**
+   * Dispatch multiple subagents in parallel with resilience
+   */
+  async dispatchParallel<T>(
+    configs: SubagentConfig[],
+    contract: SubagentContract
+  ): Promise<(T | { success: false; error: string })[]> {
+    const promises = configs.map(async config => {
+      try {
+        return await this.dispatch<T>(config, contract)
+      } catch (error) {
+        console.error(`[Dispatcher] Subagent failed:`, error)
+        return { success: false, error: (error as Error).message } as T
+      }
+    })
+
+    // Use allSettled to ensure one failure doesn't affect others
+    const results = await Promise.allSettled(promises)
+
+    return results.map(result => {
+      if (result.status === 'fulfilled') {
+        return result.value
+      } else {
+        return { success: false, error: result.reason?.message || 'Unknown error' } as T
+      }
+    })
+  }
+
+  /**
+   * Build fresh prompt with minimal context
+   */
+  private buildFreshPrompt(contract: SubagentContract): string {
+    // Only include: task description + permissions + output format
+    // Exclude: previous subagent outputs, main agent thinking
+    return `${contract.prompt}\n\nPermissions: ${JSON.stringify(contract.permissions)}`
+  }
+
+  /**
+   * Spawn subagent process
+   */
+  private async spawnSubagent(
+    config: SubagentConfig,
+    contract: SubagentContract
+  ): Promise<SubagentResult> {
+    const startTime = Date.now()
+    const freshPrompt = this.buildFreshPrompt(contract)
+
+    return new Promise((resolve, reject) => {
+      // Spawn subagent process
+      const subagent = spawn('node', ['-e', `
+        // Subagent runner - receives prompt via stdin, outputs result via stdout
+        const readline = require('readline');
+        const rl = readline.createInterface({ input: process.stdin });
+
+        let prompt = '';
+        rl.on('line', (line) => {
+          prompt += line + '\n';
+        });
+
+        rl.on('close', async () => {
+          // Simulate subagent execution (replace with actual AI call)
+          const result = {
+            id: '${this.generateId()}',
+            role: '${config.role}',
+            status: 'success',
+            output: JSON.stringify({ result: 'Task completed', prompt }),
+            artifacts: [],
+            tokensUsed: ${TokenBudget.estimateTokens(freshPrompt)},
+            duration: 0,
+            errors: []
+          };
+          console.log(JSON.stringify(result));
+        });
+      `], {
+        env: { ...process.env, CLAUDE_SUBAGENT: '1' },
+        timeout: config.timeout || 120000
+      })
+
+      let output = ''
+      let stderr = ''
+
+      subagent.stdout.on('data', (data: Buffer) => {
+        output += data.toString()
+      })
+
+      subagent.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString()
+      })
+
+      subagent.on('error', (error) => {
+        reject(error)
+      })
+
+      subagent.on('close', (code) => {
+        const duration = Date.now() - startTime
+
+        if (code === 0) {
+          try {
+            const result = JSON.parse(output)
+            resolve({
+              ...result,
+              duration
+            } as SubagentResult)
+          } catch {
+            resolve({
+              id: this.generateId(),
+              role: config.role,
+              status: 'success',
+              output,
+              artifacts: [],
+              tokensUsed: TokenBudget.estimateTokens(freshPrompt),
+              duration,
+              errors: []
+            })
+          }
+        } else {
+          reject(new Error(`Subagent exited with code ${code}: ${stderr}`))
+        }
+      })
+
+      // Send prompt
+      subagent.stdin.write(freshPrompt)
+      subagent.stdin.end()
+    })
+  }
+
+  /**
+   * Parse subagent result
+   */
+  private parseResult<T>(result: SubagentResult, contract: SubagentContract): T {
+    try {
+      const parsed = JSON.parse(result.output)
+      return parsed as T
+    } catch {
+      return result.output as unknown as T
+    }
+  }
+
+  /**
+   * Generate unique ID
+   */
+  private generateId(): string {
+    return `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  /**
+   * Get health status
+   */
+  getHealth(): {
+    circuitState: CircuitState
+    tokenUsage: { used: number; limit: number; percentage: number }
+  } {
+    return {
+      circuitState: this.circuitBreaker.getState(),
+      tokenUsage: this.tokenBudget.getUsage()
+    }
+  }
+}
+
+export { CircuitState }
+export type { CircuitBreakerConfig, RetryPolicyConfig }