Struct Client 

pub struct Client { /* private fields */ }

Client for Compose Manowar

Canonical contract for Compose manowar loops: agents, workflows, workspace indexing, and MCP/onchain connector execution.

Version: 0.8.6

Implementations

impl Client

pub fn new(baseurl: &str) -> Self

Create a new client.

baseurl is the base URL provided to the internal reqwest::Client, and should include a scheme and hostname, as well as port and a path stem if applicable.

pub fn new_with_client(baseurl: &str, client: Client) -> Self

Construct a new client with an existing reqwest::Client, allowing more control over its configuration.

baseurl is the base URL provided to the internal reqwest::Client, and should include a scheme and hostname, as well as port and a path stem if applicable.

impl Client

pub fn responses_create(&self) -> ResponsesCreate<'_>

Sends a POST request to /agent/{walletAddress}/responses

let response = client.responses_create()
    .wallet_address(wallet_address)
    .body(body)
    .send()
    .await;

pub fn runs_state_get(&self) -> RunsStateGet<'_>

Sends a GET request to /agent/{walletAddress}/runs/{runId}/state

let response = client.runs_state_get()
    .wallet_address(wallet_address)
    .run_id(run_id)
    .thread_id(thread_id)
    .send()
    .await;

pub fn stream_create(&self) -> StreamCreate<'_>

Sends a POST request to /agent/{walletAddress}/stream

let response = client.stream_create()
    .wallet_address(wallet_address)
    .x_session_active(x_session_active)
    .x_session_budget_remaining(x_session_budget_remaining)
    .x_session_user_address(x_session_user_address)
    .body(body)
    .send()
    .await;

pub fn index(&self) -> Index<'_>

Sends a POST request to /api/workspace/index

let response = client.index()
    .x_session_active(x_session_active)
    .x_session_user_address(x_session_user_address)
    .body(body)
    .send()
    .await;

pub fn search(&self) -> Search<'_>

Sends a POST request to /api/workspace/search

let response = client.search()
    .x_session_active(x_session_active)
    .x_session_user_address(x_session_user_address)
    .body(body)
    .send()
    .await;

pub fn mcp_list(&self) -> McpList<'_>

Sends a GET request to /mcps

let response = client.mcp_list()
    .category(category)
    .limit(limit)
    .offset(offset)
    .status(status)
    .send()
    .await;

pub fn mcp_categories_list(&self) -> McpCategoriesList<'_>

Sends a GET request to /mcps/categories

let response = client.mcp_categories_list()
    .send()
    .await;

pub fn mcp_meta_get(&self) -> McpMetaGet<'_>

Sends a GET request to /mcps/meta

let response = client.mcp_meta_get()
    .send()
    .await;

pub fn mcp_search(&self) -> McpSearch<'_>

Sends a GET request to /mcps/search

let response = client.mcp_search()
    .limit(limit)
    .q(q)
    .send()
    .await;

pub fn mcp_tags_list(&self) -> McpTagsList<'_>

Sends a GET request to /mcps/tags

let response = client.mcp_tags_list()
    .send()
    .await;

pub fn mcp_get(&self) -> McpGet<'_>

Sends a GET request to /mcps/{serverId}

let response = client.mcp_get()
    .server_id(server_id)
    .send()
    .await;

pub fn mcp_actions_list(&self) -> McpActionsList<'_>

Sends a GET request to /mcps/{serverId}/actions

let response = client.mcp_actions_list()
    .server_id(server_id)
    .send()
    .await;

pub fn mcp_action_execute(&self) -> McpActionExecute<'_>

Sends a POST request to /mcps/{serverId}/execute/{command}

let response = client.mcp_action_execute()
    .server_id(server_id)
    .command(command)
    .body(body)
    .send()
    .await;

pub fn mcp_inspect(&self) -> McpInspect<'_>

Sends a POST request to /mcps/{serverId}/inspect

let response = client.mcp_inspect()
    .server_id(server_id)
    .body(body)
    .send()
    .await;

pub fn mcp_spawn_get(&self) -> McpSpawnGet<'_>

Sends a GET request to /mcps/{serverId}/spawn

let response = client.mcp_spawn_get()
    .server_id(server_id)
    .send()
    .await;

pub fn onchain_list(&self) -> OnchainList<'_>

Sends a GET request to /onchain

let response = client.onchain_list()
    .send()
    .await;

pub fn onchain_get(&self) -> OnchainGet<'_>

Sends a GET request to /onchain/{connectorId}

let response = client.onchain_get()
    .connector_id(connector_id)
    .send()
    .await;

pub fn onchain_action_get(&self) -> OnchainActionGet<'_>

Sends a GET request to /onchain/{connectorId}/actions/{command}

let response = client.onchain_action_get()
    .connector_id(connector_id)
    .command(command)
    .send()
    .await;

pub fn onchain_action_execute(&self) -> OnchainActionExecute<'_>

Sends a POST request to /onchain/{connectorId}/execute/{command}

let response = client.onchain_action_execute()
    .connector_id(connector_id)
    .command(command)
    .body(body)
    .send()
    .await;

pub fn execute(&self) -> Execute<'_>

Sends a POST request to /workflow/execute

let response = client.execute()
    .x_session_active(x_session_active)
    .x_session_budget_remaining(x_session_budget_remaining)
    .x_session_user_address(x_session_user_address)
    .body(body)
    .send()
    .await;

pub fn run_alias(&self) -> RunAlias<'_>

Sends a POST request to /workflow/{id}/run

let response = client.run_alias()
    .id(id)
    .body(body)
    .send()
    .await;

pub fn runs_approval_signal(&self) -> RunsApprovalSignal<'_>

Sends a POST request to /workflow/{walletAddress}/runs/{runId}/approval

let response = client.runs_approval_signal()
    .wallet_address(wallet_address)
    .run_id(run_id)
    .body(body)
    .send()
    .await;

pub fn workflow_runs_state_get(&self) -> WorkflowRunsStateGet<'_>

Sends a GET request to /workflow/{walletAddress}/runs/{runId}/state

let response = client.workflow_runs_state_get()
    .wallet_address(wallet_address)
    .run_id(run_id)
    .send()
    .await;

pub fn stop(&self) -> Stop<'_>

Sends a POST request to /workflow/{walletAddress}/stop

let response = client.stop()
    .wallet_address(wallet_address)
    .body(body)
    .send()
    .await;

pub fn workflow_stream_create(&self) -> WorkflowStreamCreate<'_>

Sends a POST request to /workflow/{walletAddress}/stream

let response = client.workflow_stream_create()
    .wallet_address(wallet_address)
    .x_session_active(x_session_active)
    .x_session_budget_remaining(x_session_budget_remaining)
    .x_session_user_address(x_session_user_address)
    .body(body)
    .send()
    .await;

Trait Implementations

impl ClientHooks for &Client

async fn pre<E>( &self, request: &mut Request, info: &OperationInfo, ) -> Result<(), Error<E>>

Runs prior to the execution of the request. This may be used to modify the request before it is transmitted.

async fn post<E>( &self, result: &Result<Response, Error>, info: &OperationInfo, ) -> Result<(), Error<E>>

Runs after completion of the request.

async fn exec( &self, request: Request, info: &OperationInfo, ) -> Result<Response, Error>

Execute the request. Note that for almost any reasonable implementation this will include code equivalent to this:

impl ClientInfo<()> for Client

fn api_version() -> &'static str

Get the version of this API.

fn baseurl(&self) -> &str

Get the base URL to which requests are made.

fn client(&self) -> &Client

Get the internal reqwest::Client used to make requests.

fn inner(&self) -> &()

Get the inner value of type T if one is specified.

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.