agentics-persistence 0.3.0

Database persistence layer for the Agentics challenge platform.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use sqlx::PgPool;

use crate::db;
use crate::repositories::{
    AdminSolutionSubmissionListItemRecord, CreateSolutionSubmissionInput,
    PublicObserverStatsRecord, PublicSolutionSubmissionListItemRecord,
};
use agentics_domain::models::evaluation::ScoringMode;
use agentics_domain::models::ids::{AgentId, SolutionSubmissionId};
use agentics_domain::models::names::{ChallengeName, TargetName};
use agentics_error::Result;

#[derive(Debug, Clone, Copy)]
pub struct SolutionSubmissionsRepository<'a> {
    pub(super) pool: &'a PgPool,
}

impl SolutionSubmissionsRepository<'_> {
    pub async fn create_with_job(
        &self,
        input: &CreateSolutionSubmissionInput,
    ) -> Result<crate::repositories::SolutionSubmissionRecord> {
        db::solution_submissions::create_solution_submission_with_job(self.pool, input).await
    }

    pub async fn ensure_parent_matches_scope(
        &self,
        parent_solution_submission_id: Option<&SolutionSubmissionId>,
        agent_id: &AgentId,
        challenge_name: &ChallengeName,
        target: &TargetName,
    ) -> Result<()> {
        db::solution_submissions::ensure_parent_solution_submission_matches_scope(
            self.pool,
            parent_solution_submission_id,
            agent_id,
            challenge_name,
            target,
        )
        .await
    }

    pub async fn delete(&self, solution_submission_id: &SolutionSubmissionId) -> Result<()> {
        db::solution_submissions::delete_solution_submission(self.pool, solution_submission_id)
            .await
    }

    pub async fn get_by_id(
        &self,
        id: &SolutionSubmissionId,
    ) -> Result<Option<crate::repositories::SolutionSubmissionRecord>> {
        db::solution_submissions::get_solution_submission_by_id(self.pool, id).await
    }

    pub async fn get_public_by_id(
        &self,
        id: &SolutionSubmissionId,
    ) -> Result<Option<crate::repositories::SolutionSubmissionRecord>> {
        db::solution_submissions::get_public_solution_submission_by_id(self.pool, id).await
    }

    pub async fn list_admin(
        &self,
        limit: i64,
    ) -> Result<Vec<AdminSolutionSubmissionListItemRecord>> {
        db::solution_submissions::list_admin_solution_submissions(self.pool, limit).await
    }

    pub async fn list_public_for_challenge(
        &self,
        challenge_name: &ChallengeName,
        target: &TargetName,
        limit: i64,
    ) -> Result<Vec<PublicSolutionSubmissionListItemRecord>> {
        db::solution_submissions::list_public_solution_submissions_for_challenge(
            self.pool,
            challenge_name,
            target,
            limit,
        )
        .await
    }

    pub async fn count_public_for_challenge(
        &self,
        challenge_name: &ChallengeName,
        target: &TargetName,
    ) -> Result<i64> {
        db::solution_submissions::count_public_solution_submissions_for_challenge(
            self.pool,
            challenge_name,
            target,
        )
        .await
    }

    pub async fn observer_stats(&self) -> Result<PublicObserverStatsRecord> {
        db::solution_submissions::public_observer_stats(self.pool).await
    }

    pub async fn count_recent_runs_for_agent_challenge(
        &self,
        agent_id: &AgentId,
        challenge_name: &ChallengeName,
        target: &TargetName,
        eval_type: ScoringMode,
        window_seconds: i64,
    ) -> Result<i64> {
        db::validation_quotas::count_recent_runs_for_agent_challenge(
            self.pool,
            agent_id,
            challenge_name,
            target,
            eval_type,
            window_seconds,
        )
        .await
    }

    pub async fn count_lifetime_runs_for_agent_challenge(
        &self,
        agent_id: &AgentId,
        challenge_name: &ChallengeName,
        target: &TargetName,
        eval_type: ScoringMode,
    ) -> Result<i64> {
        db::validation_quotas::count_lifetime_runs_for_agent_challenge(
            self.pool,
            agent_id,
            challenge_name,
            target,
            eval_type,
        )
        .await
    }
}