use super::types::{
CertificationStatus, GenerateSkillRequest, GenerateSkillResult, OptimizeSkillRequest,
OptimizeSkillResult, SkillBrowseListResponse, SkillBrowseResponse, SkillStoreItem,
SkillStoreQuery, SkillSummary,
};
use crate::billing::entitlements::urlencoding;
use crate::core::client::Client;
use crate::core::http::{
classify_transport, parse_http_error_with_retry_after, read_limited, read_limited_text,
MAX_DOWNLOAD_SIZE, MAX_ERROR_BODY_SIZE,
};
use crate::shared::{ApiResponse, Error, Result};
use tokio_util::sync::CancellationToken;
const SKILL_TRANSFER_TIMEOUT_MS: u64 = 5 * 60 * 1000;
#[derive(Debug, Clone)]
pub struct SkillDownload {
pub data: Vec<u8>,
pub filename: String,
}
impl Client {
pub async fn browse_skill_store(
&self,
query: &SkillStoreQuery,
signal: Option<CancellationToken>,
) -> Result<Vec<SkillStoreItem>> {
let resp = self
.browse_skills(
1,
50,
query.category.as_deref().unwrap_or(""),
query.keyword.as_deref().unwrap_or(""),
query.tag.as_deref().unwrap_or(""),
"",
signal,
)
.await?;
Ok(resp.items)
}
#[allow(clippy::too_many_arguments)]
pub async fn browse_skills(
&self,
page: i64,
page_size: i64,
category: &str,
keyword: &str,
tag: &str,
source: &str,
signal: Option<CancellationToken>,
) -> Result<SkillBrowseResponse> {
let qs = build_skill_query(page, page_size, category, keyword, tag, source, false);
let env: ApiResponse<SkillBrowseResponse> = self
.do_public_json_full(&format!("/skill-store?{qs}"), signal)
.await?;
unwrap_public(&env)
}
#[allow(clippy::too_many_arguments)]
pub async fn browse_skills_list(
&self,
page: i64,
page_size: i64,
category: &str,
keyword: &str,
tag: &str,
source: &str,
signal: Option<CancellationToken>,
) -> Result<SkillBrowseListResponse> {
let qs = build_skill_query(page, page_size, category, keyword, tag, source, true);
let env: ApiResponse<SkillBrowseListResponse> = self
.do_public_json_full(&format!("/skill-store?{qs}"), signal)
.await?;
unwrap_public(&env)
}
pub async fn get_skill_detail(
&self,
skill_id: &str,
signal: Option<CancellationToken>,
) -> Result<SkillStoreItem> {
let env: ApiResponse<SkillStoreItem> = self
.do_public_json_full(&format!("/skill-store/{}", urlencoding(skill_id)), signal)
.await?;
unwrap_public(&env)
}
pub async fn resolve_skill(
&self,
key: &str,
signal: Option<CancellationToken>,
) -> Result<SkillStoreItem> {
let env: ApiResponse<SkillStoreItem> = self
.do_public_json_full(
&format!("/skill-store/resolve/{}", urlencoding(key)),
signal,
)
.await?;
unwrap_public(&env)
}
pub async fn install_skill(
&self,
skill_id: &str,
signal: Option<CancellationToken>,
) -> Result<SkillStoreItem> {
self.billing_post(
&format!("/skill-store/{}/install", urlencoding(skill_id)),
signal,
)
.await
}
pub async fn download_skill(
&self,
skill_id: &str,
signal: Option<CancellationToken>,
) -> Result<SkillDownload> {
let ctl = self.derive_timeout_token(SKILL_TRANSFER_TIMEOUT_MS, signal);
let path = format!("/skill-store/{}/download", urlencoding(skill_id));
let url = self.api_url(&path);
let mut rb = self.http().get(&url);
if let Ok(token) = self.ensure_token(ctl.clone()).await {
if !token.is_empty() {
rb = rb.header(reqwest::header::AUTHORIZATION, format!("Bearer {token}"));
}
}
let send = rb.send();
let resp = match &ctl {
Some(c) => tokio::select! {
r = send => r,
_ = c.cancelled() => return Err(Error::other("download skill: aborted")),
},
None => send.await,
}
.map_err(|e| Error::Network(classify_transport(&format!("GET {path}"), &url, &e)))?;
let status = resp.status();
if status.as_u16() == 429 {
let retry_after = resp
.headers()
.get(reqwest::header::RETRY_AFTER)
.and_then(|v| v.to_str().ok())
.unwrap_or("")
.to_string();
let body_text = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
return Err(Error::rate_limit(
"匿名下载已达限制",
retry_after,
body_text,
));
}
if !status.is_success() {
let body = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
let he = parse_http_error_with_retry_after(status.as_u16(), &body, 0);
return Err(Error::other(format!("download skill: {he}")));
}
let headers = resp.headers().clone();
let data = read_limited(resp.bytes_stream(), MAX_DOWNLOAD_SIZE + 1).await?;
if data.len() > MAX_DOWNLOAD_SIZE {
return Err(Error::other(format!(
"download skill: response exceeds {}MB limit",
MAX_DOWNLOAD_SIZE >> 20
)));
}
let filename = parse_content_disposition_filename(&headers);
Ok(SkillDownload { data, filename })
}
pub async fn upload_skill(
&self,
zip_data: Vec<u8>,
scope: &str,
intent: &str,
signal: Option<CancellationToken>,
) -> Result<SkillStoreItem> {
self.upload_skill_internal(&zip_data, scope, intent, false, signal)
.await
}
async fn upload_skill_internal(
&self,
zip_data: &[u8],
scope: &str,
intent: &str,
retried: bool,
signal: Option<CancellationToken>,
) -> Result<SkillStoreItem> {
let ctl = self.derive_timeout_token(SKILL_TRANSFER_TIMEOUT_MS, signal.clone());
let token = self.ensure_token(ctl.clone()).await?;
let part = reqwest::multipart::Part::bytes(zip_data.to_vec())
.file_name("skill.zip")
.mime_str("application/zip")
.map_err(|e| Error::other(format!("upload: build part: {e}")))?;
let form = reqwest::multipart::Form::new()
.text("scope", scope.to_string())
.text("intent", intent.to_string())
.part("file", part);
let url = self.api_url("/skill-store/upload");
let send = self
.http()
.post(&url)
.header(reqwest::header::AUTHORIZATION, format!("Bearer {token}"))
.multipart(form)
.send();
let resp = match &ctl {
Some(c) => tokio::select! {
r = send => r,
_ = c.cancelled() => return Err(Error::other("upload: aborted".to_string())),
},
None => send.await,
}
.map_err(|e| Error::Network(classify_transport("POST /skill-store/upload", &url, &e)))?;
if resp.status().as_u16() == 401 && !retried {
drop(resp);
self.force_refresh(ctl.clone()).await.map_err(|e| {
Error::other(format!("upload: unauthorized and refresh failed: {e}"))
})?;
return Box::pin(self.upload_skill_internal(zip_data, scope, intent, true, signal))
.await;
}
if !resp.status().is_success() {
let status = resp.status().as_u16();
let body = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
let he = parse_http_error_with_retry_after(status, &body, 0);
return Err(Error::other(format!("upload: {he}")));
}
let text = resp
.text()
.await
.map_err(|e| Error::other(format!("upload: read body: {e}")))?;
let env: ApiResponse<UploadData> = serde_json::from_str(&text)
.map_err(|e| Error::other(format!("upload: decode: {e}")))?;
if let Some(err) = env.business_error() {
return Err(err);
}
Ok(env.data.skill)
}
pub async fn get_skill_summary(
&self,
signal: Option<CancellationToken>,
) -> Result<SkillSummary> {
self.billing_get("/skills/summary", signal).await
}
pub async fn certify_skill(
&self,
skill_id: &str,
signal: Option<CancellationToken>,
) -> Result<()> {
let _: serde_json::Value = self
.billing_post(
&format!("/skill-store/{}/certify", urlencoding(skill_id)),
signal,
)
.await?;
Ok(())
}
pub async fn get_certification_status(
&self,
skill_id: &str,
signal: Option<CancellationToken>,
) -> Result<CertificationStatus> {
self.billing_get(
&format!("/skill-store/{}/certification", urlencoding(skill_id)),
signal,
)
.await
}
pub async fn generate_skill(
&self,
req: &GenerateSkillRequest,
signal: Option<CancellationToken>,
) -> Result<GenerateSkillResult> {
let body = serde_json::to_string(req)
.map_err(|e| Error::other(format!("serialize generate request: {e}")))?;
self.billing_post_body("/skill-generator/generate", Some(&body), signal)
.await
}
pub async fn optimize_skill(
&self,
req: &OptimizeSkillRequest,
signal: Option<CancellationToken>,
) -> Result<OptimizeSkillResult> {
let body = serde_json::to_string(req)
.map_err(|e| Error::other(format!("serialize optimize request: {e}")))?;
self.billing_post_body("/skill-generator/optimize", Some(&body), signal)
.await
}
pub async fn validate_skill(
&self,
skill_name: &str,
signal: Option<CancellationToken>,
) -> Result<()> {
let body = serde_json::json!({ "skillName": skill_name }).to_string();
let _: serde_json::Value = self
.billing_post_body("/skill-generator/validate", Some(&body), signal)
.await?;
Ok(())
}
}
#[derive(serde::Deserialize)]
struct UploadData {
skill: SkillStoreItem,
}
fn unwrap_public<T: Clone>(env: &ApiResponse<T>) -> Result<T> {
if let Some(err) = env.business_error() {
return Err(err);
}
Ok(env.data.clone())
}
fn build_skill_query(
page: i64,
page_size: i64,
category: &str,
keyword: &str,
tag: &str,
source: &str,
minimal: bool,
) -> String {
let mut parts: Vec<String> = vec![format!("page={page}"), format!("pageSize={page_size}")];
if minimal {
parts.push("fields=minimal".to_string());
}
if !category.is_empty() {
parts.push(format!("category={}", urlencoding(category)));
}
if !keyword.is_empty() {
parts.push(format!("keyword={}", urlencoding(keyword)));
}
if !tag.is_empty() {
parts.push(format!("tag={}", urlencoding(tag)));
}
if !source.is_empty() {
parts.push(format!("source={}", urlencoding(source)));
}
parts.join("&")
}
fn parse_content_disposition_filename(headers: &reqwest::header::HeaderMap) -> String {
let default = "skill.zip".to_string();
let cd = match headers
.get(reqwest::header::CONTENT_DISPOSITION)
.and_then(|v| v.to_str().ok())
{
Some(s) => s,
None => return default,
};
let idx = match cd.find("filename") {
Some(i) => i,
None => return default,
};
let tail = &cd[idx..];
let parts: Vec<&str> = tail.splitn(2, '=').collect();
if parts.len() != 2 {
return default;
}
let trimmed = parts[1]
.trim()
.trim_matches(|c| c == '"' || c == '\'' || c == ' ');
if trimmed.is_empty() {
default
} else {
trimmed.to_string()
}
}