jiq 3.21.0

Interactive JSON query tool with real-time output
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

// AI configuration type definitions

use serde::Deserialize;

/// Test constant for max context length (matches default)
#[cfg(test)]
pub const TEST_MAX_CONTEXT_LENGTH: u32 = 100_000;

// Model is now required - no default provided

/// Default max tokens for AI responses (kept short to fit in non-scrollable window)
fn default_max_tokens() -> u32 {
    512
}

/// Default max context length for JSON samples sent to AI (100KB of characters)
fn default_max_context_length() -> u32 {
    100_000
}

/// AI provider selection
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum AiProviderType {
    Anthropic,
    Bedrock,
    Openai,
    Gemini,
}

/// Anthropic-specific configuration
#[derive(Debug, Clone, Deserialize)]
pub struct AnthropicConfig {
    /// API key for Anthropic (required when AI is enabled)
    pub api_key: Option<String>,
    /// Model to use (required - user must specify)
    pub model: Option<String>,
    /// Maximum tokens in response
    #[serde(default = "default_max_tokens")]
    pub max_tokens: u32,
}

impl Default for AnthropicConfig {
    fn default() -> Self {
        AnthropicConfig {
            api_key: None,
            model: None,
            max_tokens: default_max_tokens(),
        }
    }
}

/// Bedrock provider configuration
#[derive(Debug, Clone, Deserialize, Default)]
pub struct BedrockConfig {
    /// AWS region for Bedrock API calls (required)
    pub region: Option<String>,
    /// Bedrock model ID (required, e.g., "anthropic.claude-3-haiku-20240307-v1:0")
    pub model: Option<String>,
    /// AWS profile name (optional - if not specified, uses default credential chain)
    pub profile: Option<String>,
}

/// OpenAI-specific configuration
#[derive(Debug, Clone, Deserialize, Default)]
pub struct OpenAiConfig {
    /// API key for OpenAI (required when AI is enabled with OpenAI provider)
    pub api_key: Option<String>,
    /// Model to use (required, e.g., "gpt-4o-mini")
    pub model: Option<String>,
    /// Base URL for OpenAI-compatible API (optional, defaults to api.openai.com)
    pub base_url: Option<String>,
}

/// Gemini-specific configuration
#[derive(Debug, Clone, Deserialize, Default)]
pub struct GeminiConfig {
    /// API key for Gemini (required when AI is enabled with Gemini provider)
    pub api_key: Option<String>,
    /// Model to use (required, e.g., "gemini-2.0-flash")
    pub model: Option<String>,
}

/// AI assistant configuration section
#[derive(Debug, Clone, Default, Deserialize)]
pub struct AiConfig {
    /// Whether AI features are enabled
    #[serde(default)]
    pub enabled: bool,
    /// Which AI provider to use (None when not configured)
    #[serde(default)]
    pub provider: Option<AiProviderType>,
    /// Maximum character length for JSON context samples sent to AI
    #[serde(default = "default_max_context_length")]
    pub max_context_length: u32,
    /// Anthropic-specific configuration
    #[serde(default)]
    pub anthropic: AnthropicConfig,
    /// Bedrock-specific configuration
    #[serde(default)]
    pub bedrock: BedrockConfig,
    /// OpenAI-specific configuration
    #[serde(default)]
    pub openai: OpenAiConfig,
    /// Gemini-specific configuration
    #[serde(default)]
    pub gemini: GeminiConfig,
}

#[cfg(test)]
#[path = "ai_types_tests.rs"]
mod ai_types_tests;