vtcode_config/core/
provider.rs

1use crate::core::advisor::AdvisorConfig;
2use serde::{Deserialize, Serialize};
3use vtcode_commons::reasoning::ReasoningEffortLevel;
4
5/// Controls how thinking content is returned in Anthropic API responses.
6#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
8#[serde(rename_all = "lowercase")]
9pub enum ThinkingDisplayMode {
10    /// Thinking blocks contain summarized thinking text (default on Claude 4 models).
11    Summarized,
12    /// Thinking blocks are returned with an empty `thinking` field (default on Claude Opus 4.7).
13    Omitted,
14    /// Only the short progress updates written between tool calls come back as
15    /// text; reasoning stays hidden (Claude Sonnet 5.5, Claude Opus 5.5,
16    /// Claude Fable 5.x). Sent with the `thinking-display-updates-2026-08-18`
17    /// beta.
18    Updates,
19    /// Catch-all for unknown display modes added by the Anthropic API.
20    #[serde(other)]
21    Unknown,
22}
23
24impl ThinkingDisplayMode {
25    /// Returns the string representation for the API wire format.
26    pub fn as_str(self) -> &'static str {
27        match self {
28            Self::Summarized => "summarized",
29            Self::Omitted => "omitted",
30            Self::Updates => "updates",
31            Self::Unknown => "unknown",
32        }
33    }
34}
35
36/// Native OpenAI service tier selection.
37#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
38#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
39#[serde(rename_all = "lowercase")]
40pub enum OpenAIServiceTier {
41    Flex,
42    Priority,
43    Ultrafast,
44}
45
46impl OpenAIServiceTier {
47    pub const fn as_str(self) -> &'static str {
48        match self {
49            Self::Flex => "flex",
50            Self::Priority => "priority",
51            Self::Ultrafast => "ultrafast",
52        }
53    }
54
55    pub fn parse(value: &str) -> Option<Self> {
56        let normalized = value.trim();
57        if normalized.eq_ignore_ascii_case("flex") {
58            Some(Self::Flex)
59        } else if normalized.eq_ignore_ascii_case("priority") {
60            Some(Self::Priority)
61        } else if normalized.eq_ignore_ascii_case("ultrafast") {
62            Some(Self::Ultrafast)
63        } else {
64            None
65        }
66    }
67}
68
69/// How VT Code should provision OpenAI hosted shell environments.
70#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
71#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
72#[serde(rename_all = "snake_case")]
73pub enum OpenAIHostedShellEnvironment {
74    #[default]
75    ContainerAuto,
76    ContainerReference,
77}
78
79impl OpenAIHostedShellEnvironment {
80    pub const fn as_str(self) -> &'static str {
81        match self {
82            Self::ContainerAuto => "container_auto",
83            Self::ContainerReference => "container_reference",
84        }
85    }
86}
87
88impl OpenAIHostedShellEnvironment {
89    const fn uses_container_reference(self) -> bool {
90        matches!(self, Self::ContainerReference)
91    }
92}
93
94/// Hosted shell network access policy.
95#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
96#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
97#[serde(rename_all = "snake_case")]
98pub enum OpenAIHostedShellNetworkPolicyType {
99    #[default]
100    Disabled,
101    Allowlist,
102}
103
104impl OpenAIHostedShellNetworkPolicyType {
105    pub const fn as_str(self) -> &'static str {
106        match self {
107            Self::Disabled => "disabled",
108            Self::Allowlist => "allowlist",
109        }
110    }
111}
112
113/// Per-domain secret injected by the OpenAI hosted shell runtime.
114#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
115#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
116pub struct OpenAIHostedShellDomainSecret {
117    pub domain: String,
118    pub name: String,
119    pub value: String,
120}
121
122impl OpenAIHostedShellDomainSecret {
123    fn validation_error(&self, index: usize) -> Option<String> {
124        let base = format!("provider.openai.hosted_shell.network_policy.domain_secrets[{index}]");
125
126        if self.domain.trim().is_empty() {
127            return Some(format!("`{base}.domain` must not be empty when set."));
128        }
129        if self.name.trim().is_empty() {
130            return Some(format!("`{base}.name` must not be empty when set."));
131        }
132        if self.value.trim().is_empty() {
133            return Some(format!("`{base}.value` must not be empty when set."));
134        }
135
136        None
137    }
138}
139
140/// Request-scoped network policy for OpenAI hosted shell environments.
141#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
142#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, Default)]
143pub struct OpenAIHostedShellNetworkPolicy {
144    #[serde(rename = "type", default)]
145    pub policy_type: OpenAIHostedShellNetworkPolicyType,
146
147    #[serde(default, skip_serializing_if = "Vec::is_empty")]
148    pub allowed_domains: Vec<String>,
149
150    #[serde(default, skip_serializing_if = "Vec::is_empty")]
151    pub domain_secrets: Vec<OpenAIHostedShellDomainSecret>,
152}
153
154impl OpenAIHostedShellNetworkPolicy {
155    pub const fn is_allowlist(&self) -> bool {
156        matches!(self.policy_type, OpenAIHostedShellNetworkPolicyType::Allowlist)
157    }
158
159    fn first_invalid_message(&self) -> Option<String> {
160        match self.policy_type {
161            OpenAIHostedShellNetworkPolicyType::Disabled => {
162                if !self.allowed_domains.is_empty() || !self.domain_secrets.is_empty() {
163                    return Some(
164                        "`provider.openai.hosted_shell.network_policy.allowed_domains` and `provider.openai.hosted_shell.network_policy.domain_secrets` require `provider.openai.hosted_shell.network_policy.type = \"allowlist\"`."
165                            .to_string(),
166                    );
167                }
168            }
169            OpenAIHostedShellNetworkPolicyType::Allowlist => {
170                if let Some(index) = self.allowed_domains.iter().position(|value| value.trim().is_empty()) {
171                    return Some(format!(
172                        "`provider.openai.hosted_shell.network_policy.allowed_domains[{index}]` must not be empty when set."
173                    ));
174                }
175
176                if self.allowed_domains.is_empty() {
177                    return Some(
178                        "`provider.openai.hosted_shell.network_policy.allowed_domains` must include at least one domain when `provider.openai.hosted_shell.network_policy.type = \"allowlist\"`."
179                            .to_string(),
180                    );
181                }
182
183                for (index, secret) in self.domain_secrets.iter().enumerate() {
184                    if let Some(message) = secret.validation_error(index) {
185                        return Some(message);
186                    }
187
188                    let secret_domain = secret.domain.trim();
189                    if !self
190                        .allowed_domains
191                        .iter()
192                        .any(|domain| domain.trim().eq_ignore_ascii_case(secret_domain))
193                    {
194                        return Some(format!(
195                            "`provider.openai.hosted_shell.network_policy.domain_secrets[{index}].domain` must also appear in `provider.openai.hosted_shell.network_policy.allowed_domains`."
196                        ));
197                    }
198                }
199            }
200        }
201
202        None
203    }
204}
205
206/// Reserved keyword values for hosted skill version selection.
207#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
208#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Default)]
209#[serde(rename_all = "lowercase")]
210pub enum OpenAIHostedSkillVersionKeyword {
211    #[default]
212    Latest,
213}
214
215/// Hosted skill version selector for OpenAI Responses hosted shell mounts.
216#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
217#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
218#[serde(untagged)]
219pub enum OpenAIHostedSkillVersion {
220    Latest(OpenAIHostedSkillVersionKeyword),
221    Number(u64),
222    String(String),
223}
224
225impl Default for OpenAIHostedSkillVersion {
226    fn default() -> Self {
227        Self::Latest(OpenAIHostedSkillVersionKeyword::Latest)
228    }
229}
230
231impl OpenAIHostedSkillVersion {
232    fn validation_error(&self, field_path: &str) -> Option<String> {
233        match self {
234            Self::String(value) if value.trim().is_empty() => {
235                Some(format!("`{field_path}` must not be empty when set."))
236            }
237            _ => None,
238        }
239    }
240}
241
242/// Hosted skill reference mounted into an OpenAI hosted shell environment.
243#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
244#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
245#[serde(tag = "type", rename_all = "snake_case")]
246pub enum OpenAIHostedSkill {
247    /// Reference to a pre-registered hosted skill.
248    SkillReference {
249        skill_id: String,
250        #[serde(default)]
251        version: OpenAIHostedSkillVersion,
252    },
253    /// Inline base64 zip bundle.
254    Inline {
255        bundle_b64: String,
256        #[serde(skip_serializing_if = "Option::is_none")]
257        sha256: Option<String>,
258    },
259}
260
261impl OpenAIHostedSkill {
262    fn validation_error(&self, index: usize) -> Option<String> {
263        match self {
264            Self::SkillReference { skill_id, version } => {
265                let skill_id_path = format!("provider.openai.hosted_shell.skills[{index}].skill_id");
266                if skill_id.trim().is_empty() {
267                    return Some(format!("`{skill_id_path}` must not be empty when `type = \"skill_reference\"`."));
268                }
269
270                let version_path = format!("provider.openai.hosted_shell.skills[{index}].version");
271                version.validation_error(&version_path)
272            }
273            Self::Inline { bundle_b64, .. } => {
274                let bundle_path = format!("provider.openai.hosted_shell.skills[{index}].bundle_b64");
275                if bundle_b64.trim().is_empty() {
276                    return Some(format!("`{bundle_path}` must not be empty when `type = \"inline\"`."));
277                }
278                None
279            }
280        }
281    }
282}
283
284/// OpenAI hosted shell configuration.
285#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
286#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, Default)]
287pub struct OpenAIHostedShellConfig {
288    /// Enable OpenAI hosted shell instead of VT Code's local shell tool.
289    #[serde(default)]
290    pub enabled: bool,
291
292    /// Environment provisioning mode for hosted shell.
293    #[serde(default)]
294    pub environment: OpenAIHostedShellEnvironment,
295
296    /// Existing OpenAI container ID to reuse when `environment = "container_reference"`.
297    #[serde(default, skip_serializing_if = "Option::is_none")]
298    pub container_id: Option<String>,
299
300    /// File IDs to mount when using `container_auto`.
301    #[serde(default, skip_serializing_if = "Vec::is_empty")]
302    pub file_ids: Vec<String>,
303
304    /// Hosted skills to mount when using `container_auto`.
305    #[serde(default, skip_serializing_if = "Vec::is_empty")]
306    pub skills: Vec<OpenAIHostedSkill>,
307
308    /// Request-scoped network policy for `container_auto` hosted shells.
309    #[serde(default)]
310    pub network_policy: OpenAIHostedShellNetworkPolicy,
311}
312
313impl OpenAIHostedShellConfig {
314    fn container_id_ref(&self) -> Option<&str> {
315        self.container_id.as_deref().map(str::trim).filter(|value| !value.is_empty())
316    }
317
318    pub const fn uses_container_reference(&self) -> bool {
319        self.environment.uses_container_reference()
320    }
321
322    pub fn first_invalid_skill_message(&self) -> Option<String> {
323        if self.uses_container_reference() {
324            return None;
325        }
326
327        self.skills
328            .iter()
329            .enumerate()
330            .find_map(|(index, skill)| skill.validation_error(index))
331    }
332
333    fn has_valid_skill_mounts(&self) -> bool {
334        self.first_invalid_skill_message().is_none()
335    }
336
337    pub fn first_invalid_network_policy_message(&self) -> Option<String> {
338        if self.uses_container_reference() {
339            return None;
340        }
341
342        self.network_policy.first_invalid_message()
343    }
344
345    fn has_valid_network_policy(&self) -> bool {
346        self.first_invalid_network_policy_message().is_none()
347    }
348
349    pub fn has_valid_reference_target(&self) -> bool {
350        !self.uses_container_reference() || self.container_id_ref().is_some()
351    }
352
353    pub fn is_valid_for_runtime(&self) -> bool {
354        self.has_valid_reference_target() && self.has_valid_skill_mounts() && self.has_valid_network_policy()
355    }
356}
357
358/// OpenAI hosted tool search configuration.
359#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
360#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
361pub struct OpenAIToolSearchConfig {
362    /// Enable hosted tool search for OpenAI Responses-compatible models.
363    #[serde(default = "default_tool_search_enabled")]
364    pub enabled: bool,
365
366    /// Automatically defer loading of all tools except the core always-on set.
367    #[serde(default = "default_defer_by_default")]
368    pub defer_by_default: bool,
369
370    /// Tool names that should never be deferred (always available).
371    #[serde(default)]
372    pub always_available_tools: Vec<String>,
373}
374
375impl Default for OpenAIToolSearchConfig {
376    fn default() -> Self {
377        Self {
378            enabled: default_tool_search_enabled(),
379            defer_by_default: default_defer_by_default(),
380            always_available_tools: Vec::new(),
381        }
382    }
383}
384
385/// Manual compaction defaults for the native OpenAI `/responses/compact` flow.
386#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
387#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, Default)]
388pub struct OpenAIManualCompactionConfig {
389    /// Optional custom instructions appended to manual `/compact` requests.
390    #[serde(default, skip_serializing_if = "Option::is_none")]
391    pub instructions: Option<String>,
392}
393
394/// OpenAI-specific provider configuration
395#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
396#[derive(Debug, Clone, Deserialize, Serialize, Default)]
397pub struct OpenAIConfig {
398    /// Enable persistent Responses API WebSocket generation and streaming on
399    /// native OpenAI and OpenAI-compatible Responses endpoints.
400    /// This is an opt-in path designed for long-running, tool-heavy workflows.
401    /// A persistent connection removes per-request HTTP handshake overhead, so
402    /// pair it with `service_tier = "ultrafast"` on `gpt-6-astra`/`gpt-6.1-sol`
403    /// for agentic tool-call bursts (Ultrafast docs strongly recommend WebSockets).
404    /// Streaming falls back to HTTP only before any output event is exposed.
405    #[serde(default)]
406    pub websocket_mode: bool,
407
408    /// Optional Responses API `store` flag.
409    /// Set to `false` to avoid server-side storage when using Responses-compatible models.
410    #[serde(default, skip_serializing_if = "Option::is_none")]
411    pub responses_store: Option<bool>,
412
413    /// Optional Responses API `include` selectors.
414    /// Example: `["reasoning.encrypted_content"]` for encrypted reasoning continuity.
415    #[serde(default, skip_serializing_if = "Vec::is_empty")]
416    pub responses_include: Vec<String>,
417
418    /// Optional native OpenAI `service_tier` request parameter.
419    /// Leave unset to inherit the Project-level default service tier.
420    /// Options: "flex", "priority", "ultrafast".
421    /// "ultrafast" is the fastest tier: GA for `gpt-6-astra` and `gpt-6.1-sol`,
422    /// preview-only for `gpt-5.6-sol` (contact your OpenAI account team). It costs more,
423    /// starts at low TPM limits (Astra 500k/1M/5M, 6.1-sol 1M/4M/40M), supports US/global
424    /// processing on Astra and US/EU/global on 6.1-sol, and pairs best with `websocket_mode = true`.
425    #[serde(default, skip_serializing_if = "Option::is_none")]
426    pub service_tier: Option<OpenAIServiceTier>,
427
428    /// Manual `/compact` defaults for the native OpenAI standalone compaction endpoint.
429    #[serde(default)]
430    pub manual_compaction: OpenAIManualCompactionConfig,
431
432    /// Optional hosted shell configuration for OpenAI native Responses models.
433    #[serde(default)]
434    pub hosted_shell: OpenAIHostedShellConfig,
435
436    /// Hosted tool search configuration for OpenAI Responses-compatible models.
437    #[serde(default)]
438    pub tool_search: OpenAIToolSearchConfig,
439}
440
441/// Anthropic-specific provider configuration
442#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
443#[derive(Debug, Clone, Deserialize, Serialize)]
444pub struct AnthropicConfig {
445    /// Enable adaptive or extended thinking for Anthropic models
446    /// When enabled, Claude uses internal reasoning before responding, providing
447    /// enhanced reasoning capabilities for complex tasks.
448    /// Only supported by Claude 4, Claude 4.5, and Claude 3.7 Sonnet models.
449    /// Claude Opus 4.7 uses adaptive thinking instead of budgeted extended thinking.
450    /// Note: Extended thinking is now auto-enabled by default (31,999 tokens).
451    /// Set MAX_THINKING_TOKENS=63999 environment variable for 2x budget on 64K models.
452    /// See: <https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking>
453    #[serde(default = "default_extended_thinking_enabled")]
454    pub extended_thinking_enabled: bool,
455
456    /// Beta header for interleaved thinking feature
457    #[serde(default = "default_interleaved_thinking_beta")]
458    pub interleaved_thinking_beta: String,
459
460    /// Budget tokens for extended thinking (minimum: 1024, default: 31999)
461    /// On 64K output models (Opus 4.5, Sonnet 4.5, Haiku 4.5): default 31,999, max 63,999
462    /// On 32K output models (Opus 4): max 31,999
463    /// Claude Opus 4.7 ignores this setting and uses adaptive thinking instead.
464    /// Use MAX_THINKING_TOKENS environment variable to override.
465    #[serde(default = "default_interleaved_thinking_budget_tokens")]
466    pub interleaved_thinking_budget_tokens: u32,
467
468    /// Type value for enabling interleaved thinking
469    #[serde(default = "default_interleaved_thinking_type")]
470    pub interleaved_thinking_type_enabled: String,
471
472    /// Tool search configuration for dynamic tool discovery (advanced-tool-use beta)
473    #[serde(default)]
474    pub tool_search: ToolSearchConfig,
475
476    /// Native Anthropic memory tool configuration.
477    #[serde(default)]
478    pub memory: AnthropicMemoryConfig,
479
480    /// Effort level for adaptive thinking/token usage (low, medium, high, xhigh, max)
481    /// Controls how many tokens Claude uses when responding, trading off between
482    /// response thoroughness and token efficiency.
483    /// Unset by default: each model then uses its own default effort (for example
484    /// `medium` on Claude Opus 5.5, `high` on Claude Opus 5). An explicit
485    /// `agent.reasoning_effort` or `/effort` selection takes precedence; a value the
486    /// active model does not support falls back to that model's default.
487    #[serde(default, skip_serializing_if = "Option::is_none")]
488    pub effort: Option<ReasoningEffortLevel>,
489
490    /// Optional Anthropic task budget token total for Claude Fable 5/5.1, Opus 5,
491    /// and Opus 5.5 (not sent for other models).
492    /// When set, VT Code sends `output_config.task_budget = { type = "tokens", total = N }`
493    /// and the required beta header.
494    /// Anthropic currently requires a minimum of 20,000 tokens.
495    #[serde(default)]
496    pub task_budget_tokens: Option<u32>,
497
498    /// Beta header for Anthropic task budgets.
499    #[serde(default = "default_task_budget_beta")]
500    pub task_budget_beta: String,
501
502    /// Controls how thinking content is returned in API responses.
503    ///   - "summarized": Thinking blocks contain summarized text (default on Opus 4.6 and earlier).
504    ///   - "omitted": Thinking blocks have an empty `thinking` field (default on Opus 4.7+).
505    ///   - "updates": Only the progress updates between tool calls are returned as text
506    ///     (Claude Sonnet 5.5, Claude Opus 5.5 and Claude Fable 5.x; the VT Code
507    ///     default on Claude Sonnet 5.5 and Claude Opus 5.5).
508    ///     Ignored on models without progress updates.
509    ///
510    /// When set, this overrides the model-specific default.
511    /// See: <https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#controlling-thinking-display>
512    #[serde(default)]
513    pub thinking_display: Option<ThinkingDisplayMode>,
514
515    /// Enable token counting via the count_tokens endpoint
516    /// When enabled, the agent can estimate input token counts before making API calls
517    /// Useful for proactive management of rate limits and costs
518    #[serde(default = "default_count_tokens_enabled")]
519    pub count_tokens_enabled: bool,
520
521    /// Claude Advisor server-side tool configuration. The advisor pairs a faster
522    /// executor model with a higher-intelligence advisor model for strategic
523    /// guidance mid-generation. Only honored for Anthropic models and providers.
524    #[serde(default)]
525    pub advisor: AdvisorConfig,
526
527    /// Server-side refusal fallbacks (`fallbacks` request parameter).
528    ///   - "default": let Anthropic pick the recommended fallback model when the
529    ///     primary model declines on policy grounds (the VT Code default).
530    ///   - "off": never send `fallbacks`.
531    ///   - a list of 1-3 `{ model, max_tokens }` entries tried in order.
532    ///
533    /// Only sent to the first-party Claude API (`api.anthropic.com`) for models
534    /// whose capability profile supports server-side fallbacks (Claude Opus 5,
535    /// Opus 5.5, Fable 5 and Fable 5.1); other models and endpoints send nothing.
536    #[serde(default)]
537    pub fallbacks: AnthropicFallbacks,
538}
539
540/// Keyword forms of [`AnthropicFallbacks`].
541#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
542#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq, Default)]
543#[serde(rename_all = "lowercase")]
544pub enum AnthropicFallbackMode {
545    /// Use Anthropic's recommended fallback chain (`fallbacks: "default"`).
546    #[default]
547    Default,
548    /// Do not request server-side fallbacks.
549    Off,
550}
551
552/// One explicit server-side fallback entry.
553#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
554#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
555pub struct AnthropicFallbackTarget {
556    /// Fallback model id, for example `claude-opus-4-8`.
557    pub model: String,
558    /// Optional `max_tokens` override for this fallback attempt.
559    #[serde(default, skip_serializing_if = "Option::is_none")]
560    pub max_tokens: Option<u32>,
561}
562
563/// Server-side refusal fallback selection: `"default"`, `"off"`, or an explicit
564/// list of fallback models.
565#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
566#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
567#[serde(untagged)]
568pub enum AnthropicFallbacks {
569    Mode(AnthropicFallbackMode),
570    Models(Vec<AnthropicFallbackTarget>),
571}
572
573impl Default for AnthropicFallbacks {
574    fn default() -> Self {
575        Self::Mode(AnthropicFallbackMode::Default)
576    }
577}
578
579impl AnthropicFallbacks {
580    /// Maximum number of explicit fallback entries the API accepts.
581    pub const MAX_MODELS: usize = 3;
582
583    /// Returns a validation message when an explicit list is empty, too long,
584    /// has a blank model, or repeats a model.
585    pub fn validation_error(&self, field_path: &str) -> Option<String> {
586        let Self::Models(models) = self else {
587            return None;
588        };
589        Self::entries_validation_error(
590            field_path,
591            models.iter().map(|target| (target.model.as_str(), target.max_tokens)),
592        )
593    }
594
595    /// Validates explicit fallback entries given as `(model, max_tokens)`
596    /// pairs, applying the same rules as the list form of
597    /// `provider.anthropic.fallbacks`. Shared with request-level fallback
598    /// lists so both paths reject the same payloads.
599    pub fn entries_validation_error<'a>(
600        field_path: &str,
601        entries: impl ExactSizeIterator<Item = (&'a str, Option<u32>)>,
602    ) -> Option<String> {
603        let len = entries.len();
604        if len == 0 || len > Self::MAX_MODELS {
605            return Some(format!(
606                "`{field_path}` must list between 1 and {} fallback models, or be \"default\" or \"off\".",
607                Self::MAX_MODELS
608            ));
609        }
610        let mut seen = std::collections::HashSet::with_capacity(len);
611        for (model, max_tokens) in entries {
612            let model = model.trim();
613            if model.is_empty() {
614                return Some(format!("`{field_path}` entries must set a non-empty `model`."));
615            }
616            if !seen.insert(model) {
617                return Some(format!("`{field_path}` lists `{model}` more than once; entries must be distinct."));
618            }
619            if max_tokens == Some(0) {
620                return Some(format!("`{field_path}` entry `{model}` must use a positive `max_tokens`."));
621            }
622        }
623        None
624    }
625}
626
627impl Default for AnthropicConfig {
628    fn default() -> Self {
629        Self {
630            extended_thinking_enabled: default_extended_thinking_enabled(),
631            interleaved_thinking_beta: default_interleaved_thinking_beta(),
632            interleaved_thinking_budget_tokens: default_interleaved_thinking_budget_tokens(),
633            interleaved_thinking_type_enabled: default_interleaved_thinking_type(),
634            tool_search: ToolSearchConfig::default(),
635            memory: AnthropicMemoryConfig::default(),
636            effort: None,
637            task_budget_tokens: None,
638            task_budget_beta: default_task_budget_beta(),
639            thinking_display: None,
640            count_tokens_enabled: default_count_tokens_enabled(),
641            advisor: AdvisorConfig::default(),
642            fallbacks: AnthropicFallbacks::default(),
643        }
644    }
645}
646
647#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
648#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq, Eq)]
649pub struct AnthropicMemoryConfig {
650    #[serde(default)]
651    pub enabled: bool,
652}
653
654/// OpenRouter app attribution (https://openrouter.ai/docs/app-attribution).
655///
656/// Opt-in only. When `enabled` is false no attribution headers are sent.
657/// When true, VT Code sends `HTTP-Referer`, `X-OpenRouter-Title`, and
658/// `X-OpenRouter-Categories: cli-agent`.
659#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
660#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq, Eq)]
661pub struct OpenRouterAttributionConfig {
662    /// Master opt-in switch. Default false for privacy.
663    #[serde(default)]
664    pub enabled: bool,
665
666    /// Override app URL used as `HTTP-Referer`. Defaults to the VT Code repo.
667    #[serde(default, skip_serializing_if = "Option::is_none")]
668    pub referer: Option<String>,
669
670    /// Override display name used as `X-OpenRouter-Title`. Defaults to `VT Code`.
671    #[serde(default, skip_serializing_if = "Option::is_none")]
672    pub title: Option<String>,
673}
674
675impl OpenRouterAttributionConfig {
676    /// Default referer sent when attribution is enabled and no override is set.
677    pub const DEFAULT_REFERER: &'static str = "https://github.com/vinhnx/vtcode";
678    /// Default title sent when attribution is enabled and no override is set.
679    pub const DEFAULT_TITLE: &'static str = "VT Code";
680    /// Fixed marketplace category. `cli-agent` is the allowlisted terminal-agent category.
681    pub const CATEGORIES: &'static str = "cli-agent";
682
683    /// Resolve whether attribution headers should be sent.
684    ///
685    /// The environment layer wins when set to a recognized value
686    /// (`ConfigLayerStack` env > file); unrecognized or unset values fall
687    /// through to the file value. Delegates to the canonical tri-state
688    /// parser — do not fork the accepted-value set.
689    pub fn is_enabled(&self) -> bool {
690        vtcode_commons::utils::parse_env_bool(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION, self.enabled)
691    }
692
693    /// Header-safe override check: non-empty, bounded, no CTLs (reqwest
694    /// `HeaderValue` rejects `\r`/`\n`/control bytes; fall back to defaults).
695    fn header_safe(value: &str) -> bool {
696        !value.is_empty() && value.len() <= 512 && !value.bytes().any(|b| b < 0x20 || b == 0x7F)
697    }
698
699    /// Resolve effective referer, falling back to the default. Empty or
700    /// header-unsafe overrides are ignored.
701    pub fn resolved_referer(&self) -> &str {
702        self.referer
703            .as_deref()
704            .map(str::trim)
705            .filter(|s| Self::header_safe(s))
706            .unwrap_or(Self::DEFAULT_REFERER)
707    }
708
709    /// Resolve effective title, falling back to the default. Empty or
710    /// header-unsafe overrides are ignored.
711    pub fn resolved_title(&self) -> &str {
712        self.title
713            .as_deref()
714            .map(str::trim)
715            .filter(|s| Self::header_safe(s))
716            .unwrap_or(Self::DEFAULT_TITLE)
717    }
718}
719
720/// OpenRouter-specific provider configuration.
721#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
722#[derive(Debug, Clone, Deserialize, Serialize, Default, PartialEq, Eq)]
723pub struct OpenRouterConfig {
724    /// App attribution opt-in (`[provider.openrouter.attribution]`).
725    #[serde(default)]
726    pub attribution: OpenRouterAttributionConfig,
727}
728
729#[inline]
730fn default_count_tokens_enabled() -> bool {
731    false
732}
733
734/// Tool search algorithm for Anthropic's advanced-tool-use beta
735#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
736#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
737#[serde(rename_all = "lowercase")]
738pub enum ToolSearchAlgorithm {
739    /// Regex-based search using Python re.search() syntax
740    #[default]
741    Regex,
742    /// BM25-based natural language search
743    Bm25,
744    /// Forward-compatible catch-all for unknown algorithm values
745    #[serde(other)]
746    Unknown,
747}
748
749impl ToolSearchAlgorithm {
750    /// Returns the string representation of this algorithm variant.
751    fn as_str(&self) -> &str {
752        match self {
753            Self::Regex => "regex",
754            Self::Bm25 => "bm25",
755            Self::Unknown => "unknown",
756        }
757    }
758}
759
760impl std::fmt::Display for ToolSearchAlgorithm {
761    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
762        f.write_str(self.as_str())
763    }
764}
765
766/// Configuration for Anthropic's tool search feature (advanced-tool-use beta)
767/// Enables dynamic tool discovery for large tool catalogs (up to 10k tools)
768#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
769#[derive(Debug, Clone, Deserialize, Serialize)]
770pub struct ToolSearchConfig {
771    /// Enable tool search feature (requires advanced-tool-use-2025-11-20 beta)
772    #[serde(default = "default_tool_search_enabled")]
773    pub enabled: bool,
774
775    /// Search algorithm: "regex" (Python regex patterns) or "bm25" (natural language)
776    #[serde(default = "default_tool_search_algorithm")]
777    pub algorithm: ToolSearchAlgorithm,
778
779    /// Automatically defer loading of all tools except core tools
780    #[serde(default = "default_defer_by_default")]
781    pub defer_by_default: bool,
782
783    /// Maximum number of tool search results to return
784    #[serde(default = "default_max_results")]
785    max_results: u32,
786
787    /// Tool names that should never be deferred (always available)
788    #[serde(default)]
789    pub always_available_tools: Vec<String>,
790}
791
792impl Default for ToolSearchConfig {
793    fn default() -> Self {
794        Self {
795            enabled: default_tool_search_enabled(),
796            algorithm: default_tool_search_algorithm(),
797            defer_by_default: default_defer_by_default(),
798            max_results: default_max_results(),
799            always_available_tools: vec![],
800        }
801    }
802}
803
804#[inline]
805fn default_tool_search_enabled() -> bool {
806    true
807}
808
809#[inline]
810fn default_tool_search_algorithm() -> ToolSearchAlgorithm {
811    ToolSearchAlgorithm::Regex
812}
813
814#[inline]
815fn default_defer_by_default() -> bool {
816    true
817}
818
819#[inline]
820fn default_max_results() -> u32 {
821    5
822}
823
824#[inline]
825fn default_extended_thinking_enabled() -> bool {
826    true
827}
828
829#[inline]
830fn default_interleaved_thinking_beta() -> String {
831    "interleaved-thinking-2025-05-14".to_string()
832}
833
834#[inline]
835fn default_interleaved_thinking_budget_tokens() -> u32 {
836    31999
837}
838
839#[inline]
840fn default_interleaved_thinking_type() -> String {
841    "enabled".to_string()
842}
843
844#[inline]
845fn default_task_budget_beta() -> String {
846    "task-budgets-2026-03-13".to_string()
847}
848
849#[cfg(test)]
850mod tests {
851    use super::{
852        AnthropicConfig, AnthropicFallbackMode, AnthropicFallbackTarget, AnthropicFallbacks, OpenAIConfig,
853        OpenAIHostedShellConfig, OpenAIHostedShellDomainSecret, OpenAIHostedShellEnvironment,
854        OpenAIHostedShellNetworkPolicy, OpenAIHostedShellNetworkPolicyType, OpenAIHostedSkill,
855        OpenAIHostedSkillVersion, OpenAIManualCompactionConfig, OpenAIServiceTier, OpenRouterAttributionConfig,
856        OpenRouterConfig, ToolSearchAlgorithm,
857    };
858
859    #[test]
860    fn anthropic_effort_is_unset_unless_configured() {
861        assert_eq!(AnthropicConfig::default().effort, None);
862
863        let parsed: AnthropicConfig = toml::from_str("").expect("empty anthropic config");
864        assert_eq!(parsed.effort, None);
865
866        let parsed: AnthropicConfig = toml::from_str("effort = \"high\"").expect("explicit effort");
867        assert_eq!(parsed.effort, Some(super::ReasoningEffortLevel::High));
868    }
869
870    /// `OpenAIServiceTier` keeps its `as_str()`/`parse()`/serde paths in
871    /// lockstep; see [`crate::test_support::assert_string_enum_lockstep`].
872    #[test]
873    fn openai_service_tier_string_paths_stay_in_lockstep() {
874        use crate::test_support::assert_string_enum_lockstep;
875
876        assert_string_enum_lockstep!(
877            OpenAIServiceTier,
878            [
879                OpenAIServiceTier::Flex,
880                OpenAIServiceTier::Priority,
881                OpenAIServiceTier::Ultrafast,
882            ]
883        );
884    }
885
886    #[test]
887    fn anthropic_fallbacks_default_to_default_mode() {
888        let config = AnthropicConfig::default();
889        assert_eq!(config.fallbacks, AnthropicFallbacks::Mode(AnthropicFallbackMode::Default));
890        let parsed: AnthropicConfig = toml::from_str("").expect("config should parse");
891        assert_eq!(parsed.fallbacks, AnthropicFallbacks::Mode(AnthropicFallbackMode::Default));
892    }
893
894    #[test]
895    fn anthropic_fallbacks_parse_all_three_forms() {
896        let parsed: AnthropicConfig = toml::from_str("fallbacks = \"default\"").expect("default form");
897        assert_eq!(parsed.fallbacks, AnthropicFallbacks::Mode(AnthropicFallbackMode::Default));
898
899        let parsed: AnthropicConfig = toml::from_str("fallbacks = \"off\"").expect("off form");
900        assert_eq!(parsed.fallbacks, AnthropicFallbacks::Mode(AnthropicFallbackMode::Off));
901
902        let parsed: AnthropicConfig = toml::from_str(
903            "fallbacks = [{ model = \"claude-opus-4-8\", max_tokens = 32000 }, { model = \"claude-opus-5\" }]",
904        )
905        .expect("list form");
906        assert_eq!(
907            parsed.fallbacks,
908            AnthropicFallbacks::Models(vec![
909                AnthropicFallbackTarget {
910                    model: "claude-opus-4-8".to_string(),
911                    max_tokens: Some(32_000),
912                },
913                AnthropicFallbackTarget {
914                    model: "claude-opus-5".to_string(),
915                    max_tokens: None,
916                },
917            ])
918        );
919        assert_eq!(parsed.fallbacks.validation_error("fallbacks"), None);
920
921        assert!(toml::from_str::<AnthropicConfig>("fallbacks = \"sometimes\"").is_err());
922    }
923
924    #[test]
925    fn anthropic_fallbacks_round_trip_through_serde() {
926        for fallbacks in [
927            AnthropicFallbacks::Mode(AnthropicFallbackMode::Default),
928            AnthropicFallbacks::Mode(AnthropicFallbackMode::Off),
929            AnthropicFallbacks::Models(vec![AnthropicFallbackTarget {
930                model: "claude-opus-4-8".to_string(),
931                max_tokens: None,
932            }]),
933        ] {
934            let json = serde_json::to_value(&fallbacks).expect("serialize");
935            let back: AnthropicFallbacks = serde_json::from_value(json).expect("deserialize");
936            assert_eq!(back, fallbacks);
937        }
938        assert_eq!(
939            serde_json::to_value(AnthropicFallbacks::default()).expect("serialize"),
940            serde_json::json!("default")
941        );
942    }
943
944    #[test]
945    fn anthropic_fallback_list_validation_rejects_bad_lists() {
946        let target = |model: &str| AnthropicFallbackTarget { model: model.to_string(), max_tokens: None };
947        for bad in [
948            AnthropicFallbacks::Models(vec![]),
949            AnthropicFallbacks::Models(vec![target("a"), target("b"), target("c"), target("d")]),
950            AnthropicFallbacks::Models(vec![target("  ")]),
951            AnthropicFallbacks::Models(vec![target("a"), target(" a ")]),
952            AnthropicFallbacks::Models(vec![AnthropicFallbackTarget { model: "a".to_string(), max_tokens: Some(0) }]),
953        ] {
954            assert!(bad.validation_error("fallbacks").is_some(), "{bad:?}");
955        }
956    }
957
958    #[test]
959    fn openai_config_defaults_to_websocket_mode_disabled() {
960        let config = OpenAIConfig::default();
961        assert!(!config.websocket_mode);
962        assert_eq!(config.responses_store, None);
963        assert!(config.responses_include.is_empty());
964        assert_eq!(config.service_tier, None);
965        assert_eq!(config.manual_compaction, OpenAIManualCompactionConfig::default());
966        assert_eq!(config.hosted_shell, OpenAIHostedShellConfig::default());
967        assert!(config.tool_search.enabled);
968        assert!(config.tool_search.defer_by_default);
969        assert!(config.tool_search.always_available_tools.is_empty());
970    }
971
972    #[test]
973    fn anthropic_config_defaults_native_memory_to_disabled() {
974        let config = AnthropicConfig::default();
975        assert!(!config.memory.enabled);
976    }
977
978    #[test]
979    fn anthropic_config_parses_native_memory_opt_in() {
980        let parsed: AnthropicConfig = toml::from_str("[memory]\nenabled = true").expect("config should parse");
981        assert!(parsed.memory.enabled);
982    }
983
984    #[test]
985    fn openai_config_parses_websocket_mode_opt_in() {
986        let parsed: OpenAIConfig = toml::from_str("websocket_mode = true").expect("config should parse");
987        assert!(parsed.websocket_mode);
988        assert_eq!(parsed.responses_store, None);
989        assert!(parsed.responses_include.is_empty());
990        assert_eq!(parsed.service_tier, None);
991        assert_eq!(parsed.manual_compaction, OpenAIManualCompactionConfig::default());
992        assert_eq!(parsed.hosted_shell, OpenAIHostedShellConfig::default());
993        assert_eq!(parsed.tool_search, super::OpenAIToolSearchConfig::default());
994    }
995
996    #[test]
997    fn openai_config_parses_responses_options() {
998        let parsed: OpenAIConfig = toml::from_str(
999            r#"
1000responses_store = false
1001responses_include = ["reasoning.encrypted_content", "output_text.annotations"]
1002"#,
1003        )
1004        .expect("config should parse");
1005        assert_eq!(parsed.responses_store, Some(false));
1006        assert_eq!(
1007            parsed.responses_include,
1008            vec![
1009                "reasoning.encrypted_content".to_string(),
1010                "output_text.annotations".to_string()
1011            ]
1012        );
1013        assert_eq!(parsed.service_tier, None);
1014        assert_eq!(parsed.manual_compaction, OpenAIManualCompactionConfig::default());
1015        assert_eq!(parsed.hosted_shell, OpenAIHostedShellConfig::default());
1016    }
1017
1018    #[test]
1019    fn openai_config_parses_manual_compaction_defaults() {
1020        let parsed: OpenAIConfig = toml::from_str(
1021            r#"
1022[manual_compaction]
1023instructions = "Preserve the bug reproduction steps."
1024"#,
1025        )
1026        .expect("config should parse");
1027
1028        assert_eq!(parsed.manual_compaction.instructions.as_deref(), Some("Preserve the bug reproduction steps."));
1029    }
1030
1031    #[test]
1032    fn openai_config_parses_service_tier() {
1033        let parsed: OpenAIConfig = toml::from_str(r#"service_tier = "priority""#).expect("config should parse");
1034        assert_eq!(parsed.service_tier, Some(OpenAIServiceTier::Priority));
1035    }
1036
1037    #[test]
1038    fn openai_config_parses_flex_service_tier() {
1039        let parsed: OpenAIConfig = toml::from_str(r#"service_tier = "flex""#).expect("config should parse");
1040        assert_eq!(parsed.service_tier, Some(OpenAIServiceTier::Flex));
1041    }
1042
1043    #[test]
1044    fn openai_config_parses_ultrafast_service_tier() {
1045        let parsed: OpenAIConfig = toml::from_str(r#"service_tier = "ultrafast""#).expect("config should parse");
1046        assert_eq!(parsed.service_tier, Some(OpenAIServiceTier::Ultrafast));
1047        assert_eq!(OpenAIServiceTier::Ultrafast.as_str(), "ultrafast");
1048        assert_eq!(OpenAIServiceTier::parse("ULTRAFAST"), Some(OpenAIServiceTier::Ultrafast));
1049    }
1050
1051    #[test]
1052    fn openai_config_parses_hosted_shell() {
1053        let parsed: OpenAIConfig = toml::from_str(
1054            r#"
1055[hosted_shell]
1056enabled = true
1057environment = "container_auto"
1058file_ids = ["file_123"]
1059
1060[[hosted_shell.skills]]
1061type = "skill_reference"
1062skill_id = "skill_123"
1063"#,
1064        )
1065        .expect("config should parse");
1066
1067        assert!(parsed.hosted_shell.enabled);
1068        assert_eq!(parsed.hosted_shell.environment, OpenAIHostedShellEnvironment::ContainerAuto);
1069        assert_eq!(parsed.hosted_shell.file_ids, vec!["file_123".to_string()]);
1070        assert_eq!(
1071            parsed.hosted_shell.skills,
1072            vec![OpenAIHostedSkill::SkillReference {
1073                skill_id: "skill_123".to_string(),
1074                version: OpenAIHostedSkillVersion::default(),
1075            }]
1076        );
1077    }
1078
1079    #[test]
1080    fn openai_config_parses_hosted_shell_pinned_version_and_inline_bundle() {
1081        let parsed: OpenAIConfig = toml::from_str(
1082            r#"
1083[hosted_shell]
1084enabled = true
1085
1086[[hosted_shell.skills]]
1087type = "skill_reference"
1088skill_id = "skill_123"
1089version = 2
1090
1091[[hosted_shell.skills]]
1092type = "inline"
1093bundle_b64 = "UEsFBgAAAAAAAA=="
1094sha256 = "deadbeef"
1095"#,
1096        )
1097        .expect("config should parse");
1098
1099        assert_eq!(
1100            parsed.hosted_shell.skills,
1101            vec![
1102                OpenAIHostedSkill::SkillReference {
1103                    skill_id: "skill_123".to_string(),
1104                    version: OpenAIHostedSkillVersion::Number(2),
1105                },
1106                OpenAIHostedSkill::Inline {
1107                    bundle_b64: "UEsFBgAAAAAAAA==".to_string(),
1108                    sha256: Some("deadbeef".to_string()),
1109                },
1110            ]
1111        );
1112    }
1113
1114    #[test]
1115    fn openai_config_parses_hosted_shell_network_policy() {
1116        let parsed: OpenAIConfig = toml::from_str(
1117            r#"
1118[hosted_shell]
1119enabled = true
1120
1121[hosted_shell.network_policy]
1122type = "allowlist"
1123allowed_domains = ["httpbin.org"]
1124
1125[[hosted_shell.network_policy.domain_secrets]]
1126domain = "httpbin.org"
1127name = "API_KEY"
1128value = "debug-secret-123"
1129"#,
1130        )
1131        .expect("config should parse");
1132
1133        assert_eq!(
1134            parsed.hosted_shell.network_policy,
1135            OpenAIHostedShellNetworkPolicy {
1136                policy_type: OpenAIHostedShellNetworkPolicyType::Allowlist,
1137                allowed_domains: vec!["httpbin.org".to_string()],
1138                domain_secrets: vec![OpenAIHostedShellDomainSecret {
1139                    domain: "httpbin.org".to_string(),
1140                    name: "API_KEY".to_string(),
1141                    value: "debug-secret-123".to_string(),
1142                }],
1143            }
1144        );
1145    }
1146
1147    #[test]
1148    fn openai_config_parses_tool_search() {
1149        let parsed: OpenAIConfig = toml::from_str(
1150            r#"
1151[tool_search]
1152enabled = false
1153defer_by_default = false
1154always_available_tools = ["code_search", "custom_tool"]
1155"#,
1156        )
1157        .expect("config should parse");
1158
1159        assert!(!parsed.tool_search.enabled);
1160        assert!(!parsed.tool_search.defer_by_default);
1161        assert_eq!(
1162            parsed.tool_search.always_available_tools,
1163            vec!["code_search".to_string(), "custom_tool".to_string()]
1164        );
1165    }
1166
1167    #[test]
1168    fn anthropic_tool_search_defaults_to_enabled() {
1169        let config = AnthropicConfig::default();
1170
1171        assert!(config.tool_search.enabled);
1172        assert!(config.tool_search.defer_by_default);
1173        assert_eq!(config.tool_search.algorithm, ToolSearchAlgorithm::Regex);
1174        assert!(config.tool_search.always_available_tools.is_empty());
1175    }
1176
1177    #[test]
1178    fn hosted_shell_container_reference_requires_non_empty_container_id() {
1179        let config = OpenAIHostedShellConfig {
1180            enabled: true,
1181            environment: OpenAIHostedShellEnvironment::ContainerReference,
1182            container_id: Some("   ".to_string()),
1183            file_ids: Vec::new(),
1184            skills: Vec::new(),
1185            network_policy: OpenAIHostedShellNetworkPolicy::default(),
1186        };
1187
1188        assert!(!config.has_valid_reference_target());
1189        assert!(config.container_id_ref().is_none());
1190    }
1191
1192    #[test]
1193    fn hosted_shell_reports_invalid_skill_reference_mounts() {
1194        let config = OpenAIHostedShellConfig {
1195            enabled: true,
1196            environment: OpenAIHostedShellEnvironment::ContainerAuto,
1197            container_id: None,
1198            file_ids: Vec::new(),
1199            skills: vec![OpenAIHostedSkill::SkillReference {
1200                skill_id: "   ".to_string(),
1201                version: OpenAIHostedSkillVersion::default(),
1202            }],
1203            network_policy: OpenAIHostedShellNetworkPolicy::default(),
1204        };
1205
1206        let message = config.first_invalid_skill_message().expect("invalid mount should be reported");
1207
1208        assert!(message.contains("provider.openai.hosted_shell.skills[0].skill_id"));
1209        assert!(!config.has_valid_skill_mounts());
1210        assert!(!config.is_valid_for_runtime());
1211    }
1212
1213    #[test]
1214    fn hosted_shell_ignores_skill_validation_for_container_reference() {
1215        let config = OpenAIHostedShellConfig {
1216            enabled: true,
1217            environment: OpenAIHostedShellEnvironment::ContainerReference,
1218            container_id: Some("cntr_123".to_string()),
1219            file_ids: Vec::new(),
1220            skills: vec![OpenAIHostedSkill::Inline { bundle_b64: "   ".to_string(), sha256: None }],
1221            network_policy: OpenAIHostedShellNetworkPolicy::default(),
1222        };
1223
1224        assert!(config.first_invalid_skill_message().is_none());
1225        assert!(config.has_valid_skill_mounts());
1226        assert!(config.is_valid_for_runtime());
1227    }
1228
1229    #[test]
1230    fn hosted_shell_reports_invalid_allowlist_without_domains() {
1231        let config = OpenAIHostedShellConfig {
1232            enabled: true,
1233            environment: OpenAIHostedShellEnvironment::ContainerAuto,
1234            container_id: None,
1235            file_ids: Vec::new(),
1236            skills: Vec::new(),
1237            network_policy: OpenAIHostedShellNetworkPolicy {
1238                policy_type: OpenAIHostedShellNetworkPolicyType::Allowlist,
1239                allowed_domains: Vec::new(),
1240                domain_secrets: Vec::new(),
1241            },
1242        };
1243
1244        let message = config
1245            .first_invalid_network_policy_message()
1246            .expect("invalid network policy should be reported");
1247
1248        assert!(message.contains("network_policy.allowed_domains"));
1249        assert!(!config.has_valid_network_policy());
1250        assert!(!config.is_valid_for_runtime());
1251    }
1252
1253    #[test]
1254    fn hosted_shell_reports_domain_secret_outside_allowlist() {
1255        let config = OpenAIHostedShellConfig {
1256            enabled: true,
1257            environment: OpenAIHostedShellEnvironment::ContainerAuto,
1258            container_id: None,
1259            file_ids: Vec::new(),
1260            skills: Vec::new(),
1261            network_policy: OpenAIHostedShellNetworkPolicy {
1262                policy_type: OpenAIHostedShellNetworkPolicyType::Allowlist,
1263                allowed_domains: vec!["pypi.org".to_string()],
1264                domain_secrets: vec![OpenAIHostedShellDomainSecret {
1265                    domain: "httpbin.org".to_string(),
1266                    name: "API_KEY".to_string(),
1267                    value: "secret".to_string(),
1268                }],
1269            },
1270        };
1271
1272        let message = config
1273            .first_invalid_network_policy_message()
1274            .expect("invalid domain secret should be reported");
1275
1276        assert!(message.contains("domain_secrets[0].domain"));
1277        assert!(!config.has_valid_network_policy());
1278    }
1279
1280    #[test]
1281    fn hosted_shell_ignores_network_policy_validation_for_container_reference() {
1282        let config = OpenAIHostedShellConfig {
1283            enabled: true,
1284            environment: OpenAIHostedShellEnvironment::ContainerReference,
1285            container_id: Some("cntr_123".to_string()),
1286            file_ids: Vec::new(),
1287            skills: Vec::new(),
1288            network_policy: OpenAIHostedShellNetworkPolicy {
1289                policy_type: OpenAIHostedShellNetworkPolicyType::Allowlist,
1290                allowed_domains: Vec::new(),
1291                domain_secrets: Vec::new(),
1292            },
1293        };
1294
1295        assert!(config.first_invalid_network_policy_message().is_none());
1296        assert!(config.has_valid_network_policy());
1297    }
1298
1299    /// Stash `VTCODE_OPENROUTER_ATTRIBUTION` for hermetic attribution tests
1300    /// (serialized via `serial` + the process-wide env lock; restored after).
1301    fn stash_attribution_env() -> (vtcode_commons::env_lock::EnvGuard, Option<std::ffi::OsString>) {
1302        let guard = vtcode_commons::env_lock::lock();
1303        let prior = std::env::var_os(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION);
1304        guard.remove_var(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION);
1305        (guard, prior)
1306    }
1307
1308    fn restore_attribution_env(guard: &vtcode_commons::env_lock::EnvGuard, prior: Option<std::ffi::OsString>) {
1309        guard.restore_var(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION, prior);
1310    }
1311
1312    #[test]
1313    #[serial_test::serial]
1314    fn openrouter_attribution_defaults_to_disabled() {
1315        let (env, prior) = stash_attribution_env();
1316        let config = OpenRouterAttributionConfig::default();
1317        assert!(!config.enabled);
1318        assert!(!config.is_enabled());
1319        assert_eq!(config.resolved_referer(), OpenRouterAttributionConfig::DEFAULT_REFERER);
1320        assert_eq!(config.resolved_title(), OpenRouterAttributionConfig::DEFAULT_TITLE);
1321        assert_eq!(OpenRouterAttributionConfig::CATEGORIES, "cli-agent");
1322
1323        let parsed: OpenRouterConfig = toml::from_str("").expect("empty openrouter config");
1324        assert!(!parsed.attribution.enabled);
1325        assert!(!parsed.attribution.is_enabled());
1326        restore_attribution_env(&env, prior);
1327    }
1328
1329    #[test]
1330    #[serial_test::serial]
1331    fn openrouter_attribution_parses_opt_in_with_overrides() {
1332        let (env, prior) = stash_attribution_env();
1333        let parsed: OpenRouterConfig = toml::from_str(
1334            r#"
1335[attribution]
1336enabled = true
1337referer = "https://example.com/my-fork"
1338title = "My Fork"
1339"#,
1340        )
1341        .expect("config should parse");
1342        assert!(parsed.attribution.enabled);
1343        assert!(parsed.attribution.is_enabled());
1344        assert_eq!(parsed.attribution.resolved_referer(), "https://example.com/my-fork");
1345        assert_eq!(parsed.attribution.resolved_title(), "My Fork");
1346
1347        // Blank overrides fall back to defaults rather than sending empty headers.
1348        let blank = OpenRouterAttributionConfig {
1349            enabled: true,
1350            referer: Some("   ".to_string()),
1351            title: Some("".to_string()),
1352        };
1353        assert_eq!(blank.resolved_referer(), OpenRouterAttributionConfig::DEFAULT_REFERER);
1354        assert_eq!(blank.resolved_title(), OpenRouterAttributionConfig::DEFAULT_TITLE);
1355        restore_attribution_env(&env, prior);
1356    }
1357
1358    #[test]
1359    #[serial_test::serial]
1360    fn openrouter_attribution_env_layer_wins_over_file() {
1361        // Asymmetric both directions: env enables a disabled file, and env
1362        // disables an enabled file (env > file precedence).
1363        let (env, prior) = stash_attribution_env();
1364        let disabled = OpenRouterAttributionConfig::default();
1365        env.set_var(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION, "yes");
1366        assert!(disabled.is_enabled());
1367        env.set_var(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION, "0");
1368        let enabled = OpenRouterAttributionConfig { enabled: true, referer: None, title: None };
1369        assert!(!enabled.is_enabled());
1370        // Unrecognized or blank env falls through to the file value.
1371        env.set_var(crate::constants::env_vars::VTCODE_OPENROUTER_ATTRIBUTION, "maybe");
1372        assert!(enabled.is_enabled());
1373        assert!(!disabled.is_enabled());
1374        restore_attribution_env(&env, prior);
1375    }
1376
1377    #[test]
1378    fn openrouter_attribution_rejects_header_unsafe_overrides() {
1379        // CRLF/CTL injection attempts fall back to defaults instead of
1380        // reaching reqwest header construction.
1381        let injected = OpenRouterAttributionConfig {
1382            enabled: true,
1383            referer: Some("https://example.com/\r\nX-Injected: 1".to_string()),
1384            title: Some("bad\ttitle\x7F".to_string()),
1385        };
1386        assert_eq!(injected.resolved_referer(), OpenRouterAttributionConfig::DEFAULT_REFERER);
1387        assert_eq!(injected.resolved_title(), OpenRouterAttributionConfig::DEFAULT_TITLE);
1388
1389        let oversized = OpenRouterAttributionConfig {
1390            enabled: true,
1391            referer: Some(format!("https://example.com/{}", "a".repeat(600))),
1392            title: None,
1393        };
1394        assert_eq!(oversized.resolved_referer(), OpenRouterAttributionConfig::DEFAULT_REFERER);
1395    }
1396}
vtcode_config/core/provider.rs

vtcode_config/core/
provider.rs
