nemo-flow-adaptive 0.2.0

Adaptive runtime primitives and Redis-backed learning components for NeMo Flow.
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

// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

//! OpenAI semantic hint translation.

use chrono::Utc;
use uuid::Uuid;

use crate::acg::plugin::PluginInput;
use crate::acg::translation::{
    HintPlan, HintTranslation, HintTranslator, OpenAIHintDirective, stable_prefix_target,
};
use crate::acg::types::{
    IntentOutcome, IntentType, OptimizationIntent, ReasonCode, TranslationReport, TranslationStatus,
};

/// OpenAI semantic hint translator.
pub(crate) struct OpenAIHintTranslator;

impl HintTranslator for OpenAIHintTranslator {
    fn provider_id(&self) -> &str {
        "openai"
    }

    fn translate(&self, input: &PluginInput<'_>) -> crate::acg::Result<HintTranslation> {
        let mut hint_plan = HintPlan::new(self.provider_id());
        let mut outcomes = Vec::new();

        for intent in &input.intent_bundle.intents {
            match intent {
                OptimizationIntent::CacheStability(cache_stability) => {
                    hint_plan.push(OpenAIHintDirective::CanonicalizeToolSchemas);
                    hint_plan.push(OpenAIHintDirective::CanonicalizeStablePrefix {
                        target: stable_prefix_target(
                            input.prompt_ir,
                            cache_stability.stable_prefix_end,
                        ),
                    });

                    outcomes.push(IntentOutcome {
                        intent_id: Uuid::new_v4(),
                        intent_type: IntentType::CacheStability,
                        status: TranslationStatus::Applied,
                        reason: ReasonCode::FullySupported,
                        detail: Some(
                            "deterministic serialization planned for tool schemas and stable prompt prefix"
                                .to_string(),
                        ),
                    });
                }
                OptimizationIntent::Retention(_) => {
                    outcomes.push(IntentOutcome {
                        intent_id: Uuid::new_v4(),
                        intent_type: IntentType::Retention,
                        status: TranslationStatus::Ignored,
                        reason: ReasonCode::UnsupportedByBackend,
                        detail: Some(
                            "OpenAI automatic caching does not support retention control; cache duration is managed automatically by OpenAI".to_string(),
                        ),
                    });
                }
                other => {
                    let intent_type = other.discriminant();
                    outcomes.push(IntentOutcome {
                        intent_id: Uuid::new_v4(),
                        intent_type,
                        status: TranslationStatus::Ignored,
                        reason: ReasonCode::NotRelevant,
                        detail: Some(format!(
                            "OpenAI plugin does not handle {intent_type:?} intents"
                        )),
                    });
                }
            }
        }

        Ok(HintTranslation {
            hint_plan,
            translation_report: TranslationReport {
                request_id: input.intent_bundle.request_id,
                plugin_id: self.provider_id().to_string(),
                outcomes,
                created_at: Utc::now(),
            },
        })
    }
}