pub struct Client { /* private fields */ }Expand description
HTTP client with the bearer token baked into its default headers.
Cheap to clone (it’s a thin wrapper around reqwest::Client, which is
itself an Arc internally), so prefer cloning over re-building.
Implementations§
Source§impl Client
impl Client
Sourcepub fn new(base_url: impl Into<String>, token: Token) -> Result<Self>
pub fn new(base_url: impl Into<String>, token: Token) -> Result<Self>
Build a client for the given platform base URL, authenticated with
token. The base URL’s trailing slash (if any) is stripped.
Sourcepub fn base_url(&self) -> &str
pub fn base_url(&self) -> &str
Base URL the client was configured with, with any trailing slash
stripped. Useful for callers that want to print a clickable link
alongside an API result ({base_url}/projects/…).
Sourcepub async fn get_json<T: DeserializeOwned>(&self, path: &str) -> Result<T>
pub async fn get_json<T: DeserializeOwned>(&self, path: &str) -> Result<T>
GET {path} and decode the JSON response.
Sourcepub async fn get_json_query<T: DeserializeOwned, Q: Serialize + ?Sized>(
&self,
path: &str,
query: &Q,
) -> Result<T>
pub async fn get_json_query<T: DeserializeOwned, Q: Serialize + ?Sized>( &self, path: &str, query: &Q, ) -> Result<T>
GET {path}?query and decode the JSON response. query is any
serde::Serialize — typically a &[(K, V)] or a struct.
Sourcepub async fn post_json<T: DeserializeOwned, B: Serialize + ?Sized>(
&self,
path: &str,
body: &B,
) -> Result<T>
pub async fn post_json<T: DeserializeOwned, B: Serialize + ?Sized>( &self, path: &str, body: &B, ) -> Result<T>
POST {path} with body serialized as JSON, decode the JSON
response.
Sourcepub async fn post_empty(&self, path: &str) -> Result<()>
pub async fn post_empty(&self, path: &str) -> Result<()>
POST {path} with no body, expecting an empty/ignored response.
Sourcepub async fn post_empty_returning_json<T: DeserializeOwned>(
&self,
path: &str,
) -> Result<T>
pub async fn post_empty_returning_json<T: DeserializeOwned>( &self, path: &str, ) -> Result<T>
POST {path} with no body, decoding the JSON response. The CLI
uses this for …/finalize endpoints that take no body but return
the updated row.
Sourcepub async fn put_proxy_bytes(&self, path: &str, body: Vec<u8>) -> Result<()>
pub async fn put_proxy_bytes(&self, path: &str, body: Vec<u8>) -> Result<()>
PUT {path} with body as application/octet-stream. Used by
the CLI’s models push to ship bytes through the platform’s
proxy upload route when R2 isn’t directly reachable.
Sourcepub async fn put_raw_bytes(
&self,
path: &str,
content_type: &str,
body: Vec<u8>,
) -> Result<()>
pub async fn put_raw_bytes( &self, path: &str, content_type: &str, body: Vec<u8>, ) -> Result<()>
PUT {path} with body and a caller-chosen content type. The
bearer’s auth header rides along (per the default-headers map),
so this is for routes on the platform itself — not for
presigned R2 PUTs. Voice recording bytes go through here.
Sourcepub async fn put_presigned_bytes(
presigned_url: &str,
body: Vec<u8>,
) -> Result<()>
pub async fn put_presigned_bytes( presigned_url: &str, body: Vec<u8>, ) -> Result<()>
PUT raw bytes to a presigned URL. Deliberately uses a fresh
reqwest::Client (no auth headers) — adding Authorization: Bearer … would make S3/R2 reject the request because it’s not
part of the SigV4 query-string signature.
Sourcepub async fn get_stream_to<W: AsyncWriteExt + Unpin>(
&self,
path: &str,
sink: &mut W,
) -> Result<u64>
pub async fn get_stream_to<W: AsyncWriteExt + Unpin>( &self, path: &str, sink: &mut W, ) -> Result<u64>
Stream a GET response body into sink. Returns the number of
bytes written. Used for big payloads (manifests, audio clips)
where holding the whole body in memory would be wasteful.
Source§impl Client
impl Client
Sourcepub async fn whoami(&self) -> Result<Me>
pub async fn whoami(&self) -> Result<Me>
Fetch the signed-in user from /api/me. The canonical way to
verify a freshly-minted token is reachable.
Sourcepub async fn revoke_current_token(&self) -> Result<()>
pub async fn revoke_current_token(&self) -> Result<()>
Revoke the bearer token this client is using. After this returns
successfully, the same token will start producing 401s — drop the
Client (and clear whatever storage held the token).
Source§impl Client
impl Client
Sourcepub async fn sync<E: SyncEndpoint>(
&self,
items: &[E::Record],
) -> Result<SyncResponse>
pub async fn sync<E: SyncEndpoint>( &self, items: &[E::Record], ) -> Result<SyncResponse>
POST /api/voice/{E::RESOURCE}/sync — idempotent batch upload.
The platform upserts keyed by (user_id, item.source_id), so
retries after a flaky connection are safe.
Batch size. The platform rejects batches over 100 items with
HTTP 413. This method does not chunk for you — pass a slice
you’re confident about, or use the daemon’s Uploader<E> which
chunks at 50.
Schema version. Records whose envelope leaves
schemaVersion unset (the common case — consumers don’t need
to know the number) have it stamped with
SyncEndpoint::CURRENT_SCHEMA_VERSION before serialization,
so the platform always sees an explicit version. Records that
set it explicitly are passed through untouched.
Source§impl Client
impl Client
Sourcepub async fn sync_recordings(
&self,
items: &[VoiceRecordingRecord],
) -> Result<VoiceRecordingsSyncResponse>
pub async fn sync_recordings( &self, items: &[VoiceRecordingRecord], ) -> Result<VoiceRecordingsSyncResponse>
POST /api/voice/recordings/sync — idempotent batch upsert of
recording metadata. Returns the per-item r2Key the daemon
should target for the follow-up bytes PUT, and whether bytes
have already landed for each row.
Batch sizing rules match Client::sync: the platform rejects
batches over 100 items; the daemon’s uploader chunks at 50.
Sourcepub async fn upload_recording_bytes(
&self,
source_id: &str,
bytes: Vec<u8>,
) -> Result<()>
pub async fn upload_recording_bytes( &self, source_id: &str, bytes: Vec<u8>, ) -> Result<()>
PUT /api/voice/recordings/{sourceId}/bytes — upload the WAV
bytes for a recording whose metadata was previously synced via
Client::sync_recordings. The platform refuses (HTTP 413)
if bytes.len() disagrees with the synced sizeBytes.
source_id is path-segmented as-is; callers pass the
daemon-side UUID they used for the metadata sync. Empty /
path-traversal-shaped ids are not specifically guarded here —
the platform’s Zod schema rejects them server-side, so a
malformed id surfaces as a 4xx via Error::Http.