orchestral-runtime 0.1.0

Thread Runtime with concurrency, interruption, scheduling, LLM planners, actions, and API for Orchestral
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

use serde_json::Value;

use orchestral_core::types::{ContinuationState, ContinuationStatus};

/// Derivation policy for structured assessment (local enum replacing the removed core type).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum DerivationPolicy {
    Strict,
    Permissive,
}

use super::support::{
    extract_assumptions, extract_unknowns, parse_patch_candidates_envelope,
    structured_candidate_files,
};

pub(super) fn assess_structured_readiness(
    inspection: &Value,
    patch_candidates: &Value,
    raw_policy: &str,
) -> Result<(Value, String), String> {
    let policy = parse_derivation_policy(raw_policy)?;
    let files = inspection
        .get("files")
        .and_then(Value::as_array)
        .ok_or_else(|| "structured inspection is missing files".to_string())?;
    if files.is_empty() {
        return Err("structured inspection produced no files".to_string());
    }

    let envelope = parse_patch_candidates_envelope(patch_candidates);
    let candidate_files = structured_candidate_files(patch_candidates);
    let mut unknowns = envelope
        .as_ref()
        .map(|value| value.unknowns.clone())
        .unwrap_or_else(|| extract_unknowns(patch_candidates));
    let assumptions = envelope
        .as_ref()
        .map(|value| value.assumptions.clone())
        .unwrap_or_else(|| extract_assumptions(patch_candidates));
    let mut operation_count = 0usize;
    let mut missing_input_files = Vec::new();

    for file in &candidate_files {
        let file_operation_count = file
            .get("operations")
            .and_then(Value::as_array)
            .map(|items| items.len())
            .unwrap_or(0);
        if file
            .get("needs_user_input")
            .and_then(Value::as_bool)
            .unwrap_or(false)
            && file_operation_count == 0
        {
            if let Some(path) = file.get("path").and_then(Value::as_str) {
                missing_input_files.push(format!("{} requires additional user input", path));
            }
        }
        operation_count += file_operation_count;
    }

    unknowns.extend(missing_input_files);

    unknowns.sort();
    unknowns.dedup();

    if operation_count == 0 && unknowns.is_empty() {
        let continuation = ContinuationState {
            status: ContinuationStatus::Done,
            reason: "structured inspection found no required changes".to_string(),
            unknowns: Vec::new(),
            assumptions,
            user_message: None,
        };
        return Ok((
            serde_json::to_value(continuation).map_err(|err| err.to_string())?,
            "Structured probe found no required changes.".to_string(),
        ));
    }

    let should_wait = match policy {
        DerivationPolicy::Strict => !unknowns.is_empty(),
        DerivationPolicy::Permissive => operation_count == 0 && !unknowns.is_empty(),
    };

    if should_wait {
        let user_message = format!("Need more input before commit: {}.", unknowns.join("; "));
        let continuation = ContinuationState {
            status: ContinuationStatus::WaitUser,
            reason: user_message.clone(),
            unknowns,
            assumptions,
            user_message: Some(user_message.clone()),
        };
        return Ok((
            serde_json::to_value(continuation).map_err(|err| err.to_string())?,
            "Structured probe needs user input before commit.".to_string(),
        ));
    }

    let continuation = ContinuationState {
        status: ContinuationStatus::CommitReady,
        reason: format!(
            "structured probe derived {} patch operation(s) across {} file(s)",
            operation_count,
            candidate_files.len()
        ),
        unknowns: Vec::new(),
        assumptions,
        user_message: None,
    };
    Ok((
        serde_json::to_value(continuation).map_err(|err| err.to_string())?,
        format!(
            "Structured probe ready for commit with {} patch operation(s).",
            operation_count
        ),
    ))
}

fn parse_derivation_policy(raw_policy: &str) -> Result<DerivationPolicy, String> {
    match raw_policy.trim().to_ascii_lowercase().as_str() {
        "strict" => Ok(DerivationPolicy::Strict),
        "" | "permissive" => Ok(DerivationPolicy::Permissive),
        other => {
            tracing::debug!(
                derivation_policy = other,
                "structured_assess_readiness defaulting unknown derivation_policy to permissive"
            );
            Ok(DerivationPolicy::Permissive)
        }
    }
}