deepstrike-sdk 0.2.37

DeepStrike Rust SDK — agent framework built on deepstrike-core
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

use async_trait::async_trait;

#[derive(Debug, Clone)]
pub struct Criterion {
    pub text: String,
    pub required: bool,
    pub weight: f32,
    /// I3.3 (A4): optional stable id from the host's contract layer; threaded to `VerdictFn`.
    pub id: Option<String>,
    /// I3.3 (A4): host hint — host has a deterministic check for this criterion.
    pub machine_checkable: Option<bool>,
}

impl Criterion {
    pub fn required(text: impl Into<String>) -> Self {
        Self {
            text: text.into(),
            required: true,
            weight: 1.0,
            id: None,
            machine_checkable: None,
        }
    }

    pub fn optional(text: impl Into<String>) -> Self {
        Self {
            text: text.into(),
            required: false,
            weight: 1.0,
            id: None,
            machine_checkable: None,
        }
    }

    pub fn with_weight(mut self, w: f32) -> Self {
        self.weight = w;
        self
    }

    /// I3.3 (A4): attach a stable identifier so `VerdictFn` can dispatch per-criterion checks.
    pub fn with_id(mut self, id: impl Into<String>) -> Self {
        self.id = Some(id.into());
        self
    }

    /// I3.3 (A4): mark this criterion as host-checkable (deterministic) for `VerdictFn` dispatch.
    pub fn machine_checkable(mut self, on: bool) -> Self {
        self.machine_checkable = Some(on);
        self
    }
}

#[derive(Debug, Clone)]
pub struct CriterionResult {
    pub criterion: String,
    pub passed: bool,
    pub score: f32,
    pub feedback: String,
}

#[derive(Debug, Clone)]
pub struct HarnessRequest {
    pub goal: String,
    pub criteria: Vec<Criterion>,
    pub extensions: Option<serde_json::Value>,
}

impl HarnessRequest {
    pub fn new(goal: impl Into<String>) -> Self {
        Self {
            goal: goal.into(),
            criteria: Vec::new(),
            extensions: None,
        }
    }
}

#[derive(Debug, Clone)]
pub struct HarnessOutcome {
    pub result: String,
    pub passed: bool,
    pub iterations: u32,
    pub total_tokens: u64,
    pub status: String,
    pub overall_score: f32,
    pub feedback: Option<String>,
    pub details: Vec<CriterionResult>,
}

#[derive(Debug, Clone)]
pub struct Verdict {
    pub passed: bool,
    pub overall_score: f32,
    pub feedback: String,
    pub details: Vec<CriterionResult>,
}

#[derive(Debug, Clone)]
pub enum HarnessEvent {
    Token(String),
    ToolCall {
        id: String,
        name: String,
    },
    ToolResult {
        call_id: String,
        content: String,
        is_error: bool,
    },
    Supervising,
    Revising {
        verdict: Verdict,
    },
    Done {
        verdict: Verdict,
        iterations: u32,
        total_tokens: u64,
        status: String,
    },
    MaxAttemptsReached,
}

#[async_trait]
pub trait QualityGate: Send + Sync {
    async fn evaluate(
        &self,
        request: &HarnessRequest,
        outcome: &HarnessOutcome,
    ) -> crate::Result<bool>;
}

#[async_trait]
pub trait Harness: Send + Sync {
    async fn run(&self, request: HarnessRequest) -> crate::Result<HarnessOutcome>;
}