wave-agent-sdk 1.0.0 → 1.0.1

package/src/managers/goalManager.ts

@@ -1,232 +0,0 @@
-import { Container } from "../utils/container.js";
-import type { MessageManager } from "./messageManager.js";
-import type { AIManager } from "./aiManager.js";
-import type { Usage } from "../types/index.js";
-import { evaluateGoal as aiEvaluateGoal } from "../services/aiService.js";
-import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
-import { logger } from "../utils/globalLogger.js";
-
-export interface GoalState {
-  condition: string;
-  startedAt: number;
-  turnCount: number;
-  tokenBaseline: number;
-  lastReason?: string;
-  consecutiveEvalFailures: number;
-}
-
-const MAX_GOAL_TURNS = 50;
-const MAX_GOAL_DURATION_MS = 30 * 60 * 1000; // 30 minutes
-const MAX_CONSECUTIVE_EVAL_FAILURES = 3;
-const MAX_CONDITION_LENGTH = 4000;
-
-export class GoalManager {
-  private state: GoalState | null = null;
-  private onGoalStateChange?: (
-    active: boolean,
-    condition?: string,
-    elapsed?: string,
-  ) => void;
-  private onGoalEvaluating?: (evaluating: boolean) => void;
-
-  constructor(private container: Container) {}
-
-  private get messageManager(): MessageManager {
-    return this.container.get<MessageManager>("MessageManager")!;
-  }
-
-  private get aiManager(): AIManager {
-    return this.container.get<AIManager>("AIManager")!;
-  }
-
-  public setOnGoalStateChange(
-    callback: (active: boolean, condition?: string, elapsed?: string) => void,
-  ): void {
-    this.onGoalStateChange = callback;
-  }
-
-  public setOnGoalEvaluating(callback: (evaluating: boolean) => void): void {
-    this.onGoalEvaluating = callback;
-  }
-
-  public setGoal(condition: string): void {
-    if (condition.length > MAX_CONDITION_LENGTH) {
-      throw new Error(
-        `Goal condition exceeds maximum length of ${MAX_CONDITION_LENGTH} characters`,
-      );
-    }
-
-    const totalTokens = this.messageManager.getLatestTotalTokens?.() ?? 0;
-
-    this.state = {
-      condition,
-      startedAt: Date.now(),
-      turnCount: 0,
-      tokenBaseline: totalTokens,
-      consecutiveEvalFailures: 0,
-    };
-
-    this.onGoalStateChange?.(true, condition, "0m");
-    logger?.info(`[Goal] Set goal: ${condition}`);
-  }
-
-  public clearGoal(): void {
-    if (this.state) {
-      logger?.info(`[Goal] Cleared goal: ${this.state.condition}`);
-      this.state = null;
-      this.onGoalStateChange?.(false);
-    }
-  }
-
-  public getGoal(): GoalState | null {
-    return this.state;
-  }
-
-  public isGoalActive(): boolean {
-    return this.state !== null;
-  }
-
-  public incrementTurnCount(): void {
-    if (this.state) {
-      this.state.turnCount++;
-    }
-  }
-
-  public getStatusString(): string {
-    if (!this.state) return "No active goal";
-    const elapsed = this.formatElapsed(Date.now() - this.state.startedAt);
-    let status = `Goal: ${this.state.condition}\nElapsed: ${elapsed}\nTurns: ${this.state.turnCount}`;
-    if (this.state.lastReason) {
-      status += `\nLast evaluation: ${this.state.lastReason}`;
-    }
-    return status;
-  }
-
-  /**
-   * Check circuit breakers. Returns a clear reason if goal should be force-cleared, null otherwise.
-   */
-  public checkCircuitBreakers(): string | null {
-    if (!this.state) return null;
-
-    if (this.state.turnCount >= MAX_GOAL_TURNS) {
-      return `Goal cancelled: maximum turns (${MAX_GOAL_TURNS}) exceeded`;
-    }
-
-    if (Date.now() - this.state.startedAt >= MAX_GOAL_DURATION_MS) {
-      return `Goal cancelled: time limit (${MAX_GOAL_DURATION_MS / 60000} minutes) exceeded`;
-    }
-
-    if (this.state.consecutiveEvalFailures >= MAX_CONSECUTIVE_EVAL_FAILURES) {
-      return `Goal cancelled: ${MAX_CONSECUTIVE_EVAL_FAILURES} consecutive evaluation failures`;
-    }
-
-    return null;
-  }
-
-  /**
-   * Evaluate whether the goal has been met using the fast model.
-   */
-  public async evaluateGoal(abortSignal?: AbortSignal): Promise<{
-    isMet: boolean;
-    reason: string;
-  }> {
-    if (!this.state) {
-      return { isMet: false, reason: "No active goal" };
-    }
-
-    try {
-      const messages = this.messageManager.getMessages();
-      const apiMessages = convertMessagesForAPI(messages);
-      const gatewayConfig = this.aiManager.getGatewayConfig();
-      const modelConfig = this.aiManager.getModelConfig();
-      const fastModel = modelConfig.fastModel || modelConfig.model;
-      if (!fastModel) {
-        return {
-          isMet: false,
-          reason: "No model configured for goal evaluation",
-        };
-      }
-
-      this.onGoalEvaluating?.(true);
-      const result = await aiEvaluateGoal({
-        gatewayConfig,
-        modelConfig,
-        model: fastModel,
-        goalCondition: this.state.condition,
-        messages: apiMessages,
-        abortSignal,
-      });
-
-      // Track evaluation tokens separately
-      if (result.usage) {
-        const usage: Usage = {
-          ...result.usage,
-          operation_type: "goal_evaluation",
-          model: fastModel,
-        };
-        this.messageManager.addUsage(usage);
-      }
-
-      // Reset failure counter on success
-      this.state.consecutiveEvalFailures = 0;
-
-      this.onGoalEvaluating?.(false);
-
-      // Parse the response
-      return this.parseEvaluationResponse(result.content);
-    } catch (error) {
-      this.onGoalEvaluating?.(false);
-      this.state.consecutiveEvalFailures++;
-      logger?.warn(
-        `[Goal] Evaluation failed (${this.state.consecutiveEvalFailures}/${MAX_CONSECUTIVE_EVAL_FAILURES}): ${(error as Error).message}`,
-      );
-      return {
-        isMet: false,
-        reason: `Evaluation failed: ${(error as Error).message}`,
-      };
-    }
-  }
-
-  /**
-   * Parse the evaluation response from the fast model.
-   */
-  private parseEvaluationResponse(content: string): {
-    isMet: boolean;
-    reason: string;
-  } {
-    // Try direct JSON parse
-    try {
-      const parsed = JSON.parse(content);
-      if (typeof parsed.met === "boolean") {
-        return {
-          isMet: parsed.met,
-          reason: parsed.reason || "No reason provided",
-        };
-      }
-    } catch {
-      // Fall through to regex
-    }
-
-    // Try regex extraction
-    const metMatch = content.match(/"met"\s*:\s*(true|false)/);
-    const reasonMatch = content.match(/"reason"\s*:\s*"([^"]*)"/);
-    if (metMatch) {
-      return {
-        isMet: metMatch[1] === "true",
-        reason: reasonMatch?.[1] || "No reason provided",
-      };
-    }
-
-    // Default: not met
-    return { isMet: false, reason: "Could not parse evaluation response" };
-  }
-
-  private formatElapsed(ms: number): string {
-    const minutes = Math.floor(ms / 60000);
-    if (minutes < 1) return "<1m";
-    if (minutes < 60) return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    const remainingMin = minutes % 60;
-    return `${hours}h${remainingMin}m`;
-  }
-}