bcode_bedrock_provider_plugin 0.0.1-alpha.0

Amazon Bedrock model provider plugin for bcode
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
113
114

//! Statically bundled provider configuration CLI contribution.

use bcode_plugin_sdk::path::display_from_current_dir;
use bcode_plugin_sdk::{StaticCliFuture, StaticCliOutcome, StaticCliRegistration};
use clap::{CommandFactory, FromArgMatches, Parser, Subcommand};

#[derive(Debug, Parser)]
#[command(name = "provider", about = "Configure model providers")]
struct ProviderCli {
    #[command(subcommand)]
    command: ProviderCommand,
}

#[derive(Debug, Subcommand)]
enum ProviderCommand {
    Configure {
        #[command(subcommand)]
        command: ConfigureCommand,
    },
}

#[derive(Debug, Subcommand)]
enum ConfigureCommand {
    /// Configure an Amazon Bedrock model profile.
    Bedrock {
        #[arg(long, default_value = "bedrock")]
        profile: String,
        #[arg(long)]
        aws_profile: Option<String>,
        #[arg(long)]
        region: Option<String>,
        #[arg(long)]
        endpoint_url: Option<String>,
        #[arg(long, default_value = "anthropic.claude-sonnet-4-5-20250929-v1:0")]
        model: String,
        #[arg(long = "model-id")]
        model_ids: Vec<String>,
    },
}

pub fn registration() -> StaticCliRegistration {
    StaticCliRegistration {
        requires_daemon: |_| false,
        command: ProviderCli::command,
        invoke,
    }
}

fn invoke(matches: clap::ArgMatches) -> StaticCliFuture {
    Box::pin(async move {
        let cli = ProviderCli::from_arg_matches(&matches).map_err(|error| error.to_string())?;
        run(cli.command)?;
        Ok(StaticCliOutcome::default())
    })
}

fn run(command: ProviderCommand) -> Result<(), String> {
    let ProviderCommand::Configure {
        command:
            ConfigureCommand::Bedrock {
                profile,
                aws_profile,
                region,
                endpoint_url,
                model,
                mut model_ids,
            },
    } = command;
    if !model_ids.contains(&model) {
        model_ids.insert(0, model.clone());
    }
    let config_path = bcode_config::set_bedrock_model_profile(
        &profile,
        model,
        aws_profile,
        region,
        endpoint_url.as_deref(),
        &model_ids,
    )
    .map_err(|error| error.to_string())?;
    println!(
        "Bedrock provider profile '{profile}' configured; config updated: {}",
        display_from_current_dir(&config_path)
    );
    Ok(())
}

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

    #[test]
    fn parses_bedrock_configuration() {
        let matches = ProviderCli::command()
            .try_get_matches_from([
                "provider",
                "configure",
                "bedrock",
                "--profile",
                "production",
                "--region",
                "us-east-1",
            ])
            .expect("provider command should parse");
        let cli = ProviderCli::from_arg_matches(&matches).expect("matches should decode");

        assert!(matches!(
            cli.command,
            ProviderCommand::Configure {
                command: ConfigureCommand::Bedrock { profile, region, .. }
            } if profile == "production" && region.as_deref() == Some("us-east-1")
        ));
    }
}