heddle-cli 0.2.4

An AI-native version control system
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

// SPDX-License-Identifier: Apache-2.0
use anyhow::Result;

use super::{
    HarnessActorProbe, HarnessAttachHints, HarnessProbeInput, HarnessProbeResult, ProbeSource,
    argv_value, csv_paths, parse_u64,
};

pub(crate) struct CodexProbe;

impl HarnessActorProbe for CodexProbe {
    fn harness_name(&self) -> &'static str {
        "codex"
    }

    fn matches(&self, input: &HarnessProbeInput) -> bool {
        input.explicit_harness.as_deref() == Some(self.harness_name())
            || input.probe_metadata.contains_key("thread_id")
            || input.probe_metadata.contains_key("client_name")
            || input.env_hints.contains_key("CODEX_SANDBOX")
            || input
                .argv
                .as_ref()
                .and_then(|argv| argv.first())
                .is_some_and(|program| program.to_ascii_lowercase().contains("codex"))
    }

    fn probe(&self, input: &HarnessProbeInput) -> Result<HarnessProbeResult> {
        let metadata = &input.probe_metadata;
        let argv = input.argv.as_deref().unwrap_or(&[]);
        let thread_id = metadata.get("thread_id").cloned();
        let client_name = metadata
            .get("client_name")
            .cloned()
            .or_else(|| metadata.get("client").cloned())
            .or_else(|| {
                input
                    .env_hints
                    .get("CODEX_INTERNAL_ORIGINATOR_OVERRIDE")
                    .cloned()
            });
        let model = metadata
            .get("model")
            .cloned()
            .or_else(|| argv_value(argv, "--model"))
            .or_else(|| input.env_hints.get("OPENAI_MODEL").cloned())
            .or_else(|| input.current_model.clone());
        let provider = metadata
            .get("model_provider")
            .cloned()
            .or_else(|| input.explicit_provider.clone())
            .or(Some("openai".to_string()))
            .or_else(|| input.current_provider.clone());
        let thinking_level = metadata
            .get("model_reasoning_effort")
            .cloned()
            .or_else(|| metadata.get("reasoning_effort").cloned())
            .or_else(|| input.env_hints.get("OPENAI_REASONING_EFFORT").cloned());
        let probe_source = if thread_id.is_some() {
            ProbeSource::AppProtocol
        } else if client_name.is_some() {
            ProbeSource::HookPayload
        } else {
            ProbeSource::ArgvEnv
        };
        Ok(HarnessProbeResult {
            harness: Some("codex".to_string()),
            provider,
            model,
            thinking_level,
            policy: input
                .explicit_policy
                .clone()
                .or_else(|| input.current_policy.clone()),
            native_actor_key: thread_id.map(|id| format!("codex:thread:{id}")),
            native_parent_actor_key: None,
            native_instance_key: client_name.map(|id| format!("codex:client:{id}")),
            usage_totals: proto::UsageTotals {
                input_tokens: parse_u64(metadata.get("input_tokens")),
                output_tokens: parse_u64(metadata.get("output_tokens")),
                reasoning_tokens: parse_u64(metadata.get("reasoning_tokens")),
                cache_creation_tokens: None,
                cache_read_tokens: None,
                tool_calls: metadata.get("tool_calls").and_then(|v| v.parse().ok()),
                cost_micros_usd: parse_u64(metadata.get("cost_micros_usd")),
            },
            touched_paths: csv_paths(metadata.get("touched_paths")),
            transcript_refs: Vec::new(),
            attach_hints: HarnessAttachHints { root_actor: true },
            confidence: Some(if matches!(probe_source, ProbeSource::AppProtocol) {
                0.98
            } else if matches!(probe_source, ProbeSource::HookPayload) {
                0.85
            } else {
                0.55
            }),
            probe_source: Some(probe_source.as_str().to_string()),
            ..HarnessProbeResult::default()
        })
    }
}