crabmate 0.4.0

Rust AI agent: OpenAI-compatible chat/completions, function calling, HTTP serve, ops CLI
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

//! 终答 Gate **只读 Context**：`require_plan` 与来源 reason 的单点解析。
//! 与工作流反思的衔接见 **`docs/design/run_loop_state_ownership.md`** 与金样
//! `workflow_to_plan_requirement_golden`。

use super::final_plan_gate::FinalPlanGatePhase;
use super::{FinalPlanRequirementMode, PlanRequirementSource};

/// 为何当前终答须（或无须）嵌入结构化规划。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum FinalPlanRequirePlanReason {
    PolicyNever,
    PolicyAlways,
    WorkflowReflectionActive,
    NoActiveRequirement,
}

impl FinalPlanRequirePlanReason {
    pub(crate) fn as_str(self) -> &'static str {
        match self {
            Self::PolicyNever => "policy_never",
            Self::PolicyAlways => "policy_always",
            Self::WorkflowReflectionActive => "workflow_reflection_active",
            Self::NoActiveRequirement => "no_active_requirement",
        }
    }
}

/// 进入 [`super::final_plan_gate::run_final_plan_gate`] 前的只读快照。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct FinalPlanGateContext {
    pub require_plan: bool,
    pub phase: FinalPlanGatePhase,
    pub require_plan_reason: FinalPlanRequirePlanReason,
}

impl FinalPlanGateContext {
    pub(crate) fn apply_layer_semantics(self) -> bool {
        matches!(
            self.require_plan_reason,
            FinalPlanRequirePlanReason::WorkflowReflectionActive
        )
    }
}

pub(crate) fn build_final_plan_gate_context(
    policy: FinalPlanRequirementMode,
    source: PlanRequirementSource,
) -> FinalPlanGateContext {
    let (require_plan, reason) = match policy {
        FinalPlanRequirementMode::Never => (false, FinalPlanRequirePlanReason::PolicyNever),
        FinalPlanRequirementMode::Always => (true, FinalPlanRequirePlanReason::PolicyAlways),
        FinalPlanRequirementMode::WorkflowReflection => {
            if source == PlanRequirementSource::WorkflowReflection {
                (true, FinalPlanRequirePlanReason::WorkflowReflectionActive)
            } else {
                (false, FinalPlanRequirePlanReason::NoActiveRequirement)
            }
        }
    };
    let phase = if require_plan {
        FinalPlanGatePhase::CheckStructuredPlan
    } else {
        FinalPlanGatePhase::NoRequirement
    };
    FinalPlanGateContext {
        require_plan,
        phase,
        require_plan_reason: reason,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn workflow_reflection_only_when_source_active() {
        let ctx = build_final_plan_gate_context(
            FinalPlanRequirementMode::WorkflowReflection,
            PlanRequirementSource::WorkflowReflection,
        );
        assert!(ctx.require_plan);
        assert_eq!(
            ctx.require_plan_reason,
            FinalPlanRequirePlanReason::WorkflowReflectionActive
        );
        assert!(ctx.apply_layer_semantics());
    }

    #[test]
    fn workflow_reflection_policy_without_source() {
        let ctx = build_final_plan_gate_context(
            FinalPlanRequirementMode::WorkflowReflection,
            PlanRequirementSource::None,
        );
        assert!(!ctx.require_plan);
        assert_eq!(ctx.phase, FinalPlanGatePhase::NoRequirement);
    }
}