Class InMemoryEvaluationStore

src/evaluator/inMemoryStore.ts:34–161

}

export class InMemoryEvaluationStore
  implements EvaluationStore<InMemoryEvaluation, EvaluateResult>
{
  private readonly failedResultsByIndex: Map<string, EvaluateResult>;
  private readonly finalResultsByIndex: Map<string, EvaluateResult>;

  constructor(readonly evaluation: InMemoryEvaluation) {
    this.failedResultsByIndex = toResultMap(evaluation.failedResults);
    this.finalResultsByIndex = toResultMap(evaluation.finalResults);
    if (this.failedResultsByIndex.size > 0) {
      evaluation.resultPersistenceFailed = true;
    }
    this.syncFailedResults();
    this.syncFinalResults();
  }

  get id(): string {
    return this.evaluation.id;
  }

  get config(): Partial<UnifiedConfig> {
    return this.evaluation.config;
  }

  get persisted(): boolean {
    return this.evaluation.persisted;
  }

  get prompts(): CompletedPrompt[] {
    return this.evaluation.prompts;
  }

  get results(): EvaluateResult[] {
    return this.evaluation.results;
  }

  get resultPersistenceFailed(): boolean {
    return this.evaluation.resultPersistenceFailed;
  }

  async appendResult(result: EvaluateResult): Promise<void> {
    this.evaluation.results.push(result);
  }

  async appendPrompts(prompts: CompletedPrompt[]): Promise<void> {
    this.evaluation.prompts = prompts;
  }

  hasResultPersistenceFailure(result: Pick<EvaluateResult, 'promptIdx' | 'testIdx'>): boolean {
    return this.failedResultsByIndex.has(getResultIndexKey(result));
  }

  async readCompletedIndexPairs(options?: { excludeErrors?: boolean }): Promise<Set<string>> {
    const completedPairs = new Set<string>();
    for (const result of this.evaluation.results) {
      if (options?.excludeErrors && result.failureReason === ERROR_FAILURE_REASON) {
        continue;
      }