use crate::core::client::Client;
use crate::shared::{ApiResponse, Result};
use serde::Deserialize;
use serde_json::json;
use tokio_util::sync::CancellationToken;
pub const BYOK_PROVIDER_ANTHROPIC: &str = "anthropic";
pub const BYOK_PROVIDER_OPENAI: &str = "openai";
pub const BYOK_PROVIDER_DEEPSEEK: &str = "deepseek";
pub const BYOK_PROVIDER_DASHSCOPE: &str = "dashscope";
pub const BYOK_PROVIDER_ZHIPU: &str = "zhipu";
pub const BYOK_PROVIDER_VOLCENGINE: &str = "volcengine";
pub const BYOK_PROVIDER_CUSTOM: &str = "custom";
pub const BYOK_STATUS_ACTIVE: &str = "active";
pub const BYOK_STATUS_REVOKED: &str = "revoked";
#[derive(Debug, Clone, Default)]
pub struct ByokCredential {
pub credential_ref: String,
pub provider: String,
pub name: Option<String>,
pub base_url: Option<String>,
pub fingerprint: Option<String>,
pub status: String,
pub created_at: Option<String>,
pub last_used_at: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct ByokCreateRequest {
pub provider: String,
pub plaintext: String,
pub name: Option<String>,
pub base_url: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize)]
struct WireByokCredential {
#[serde(default)]
credential_ref: Option<String>,
#[serde(default)]
provider: Option<String>,
#[serde(default)]
name: Option<String>,
#[serde(default)]
base_url: Option<String>,
#[serde(default)]
fingerprint: Option<String>,
#[serde(default)]
status: Option<String>,
#[serde(default)]
created_at: Option<String>,
#[serde(default)]
last_used_at: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize)]
struct WireByokList {
#[serde(default)]
items: Option<Vec<WireByokCredential>>,
}
fn non_empty(s: Option<String>) -> Option<String> {
s.filter(|v| !v.is_empty())
}
fn from_wire_byok(v: WireByokCredential) -> ByokCredential {
ByokCredential {
credential_ref: v.credential_ref.unwrap_or_default(),
provider: v.provider.unwrap_or_default(),
name: non_empty(v.name),
base_url: non_empty(v.base_url),
fingerprint: non_empty(v.fingerprint),
status: v.status.unwrap_or_default(),
created_at: non_empty(v.created_at),
last_used_at: non_empty(v.last_used_at),
}
}
pub struct CrabCodeByokClient {
client: Client,
}
impl CrabCodeByokClient {
pub(crate) fn new(client: Client) -> Self {
Self { client }
}
pub async fn list(&self, signal: Option<CancellationToken>) -> Result<Vec<ByokCredential>> {
let env: ApiResponse<WireByokList> = self
.client
.agent_runs_request_api("GET", "/crabcode/byok-credentials", None, signal, true)
.await?;
Ok(env
.data
.items
.unwrap_or_default()
.into_iter()
.map(from_wire_byok)
.collect())
}
pub async fn create(
&self,
req: &ByokCreateRequest,
signal: Option<CancellationToken>,
) -> Result<ByokCredential> {
let body = json!({
"provider": req.provider,
"name": req.name,
"base_url": req.base_url,
"plaintext": req.plaintext,
})
.to_string();
let env: ApiResponse<WireByokCredential> = self
.client
.agent_runs_request_api(
"POST",
"/crabcode/byok-credentials",
Some(&body),
signal,
false,
)
.await?;
Ok(from_wire_byok(env.data))
}
pub async fn rotate(
&self,
credential_ref: &str,
new_plaintext: &str,
signal: Option<CancellationToken>,
) -> Result<ByokCredential> {
let path = format!(
"/crabcode/byok-credentials/{}/rotate",
crate::billing::entitlements::urlencoding(credential_ref)
);
let body = json!({ "new_plaintext": new_plaintext }).to_string();
let env: ApiResponse<WireByokCredential> = self
.client
.agent_runs_request_api("POST", &path, Some(&body), signal, false)
.await?;
Ok(from_wire_byok(env.data))
}
pub async fn revoke(
&self,
credential_ref: &str,
signal: Option<CancellationToken>,
) -> Result<ByokCredential> {
let path = format!(
"/crabcode/byok-credentials/{}/revoke",
crate::billing::entitlements::urlencoding(credential_ref)
);
let env: ApiResponse<WireByokCredential> = self
.client
.agent_runs_request_api("POST", &path, Some("{}"), signal, false)
.await?;
Ok(from_wire_byok(env.data))
}
}
impl Client {
pub fn crabcode_byok(&self) -> CrabCodeByokClient {
CrabCodeByokClient::new(self.clone())
}
}