Struct DcpClient 

pub struct DcpClient { /* private fields */ }

DCP client for AI tool communication

Provides high-performance binary protocol communication with DCP servers, with automatic fallback to MCP when DCP is unavailable.

Implementations

impl DcpClient

pub fn new(config: DcpConfig) -> Self

Create a new DCP client with the given configuration

pub fn with_defaults() -> Self

Create a new DCP client with default configuration

pub fn state(&self) -> ConnectionState

Get the current connection state

pub fn is_connected(&self) -> bool

Check if connected (either DCP or MCP)

pub fn is_dcp_connected(&self) -> bool

Check if connected via DCP

pub fn is_mcp_connected(&self) -> bool

Check if connected via MCP

pub fn prefer_dcp(&self) -> bool

Check if DCP should be preferred over MCP

pub fn set_prefer_dcp(&mut self, prefer: bool)

Set DCP preference

pub fn enable_dcp(&mut self)

Enable DCP protocol

pub fn disable_dcp(&mut self)

Disable DCP protocol (will use MCP only)

pub fn is_dcp_enabled(&self) -> bool

Check if DCP is enabled

pub fn current_protocol(&self) -> Option<Protocol>

Get the current protocol in use

pub fn select_protocol(&self) -> Option<Protocol>

Select the best protocol for a given operation

Returns DCP if connected via DCP and DCP is preferred, otherwise returns MCP if available.

pub fn invoke_tool_auto( &self, tool_id: u32, args: &[u8], ) -> Result<InvocationResult>

Invoke a tool using the best available protocol

Automatically selects DCP or MCP based on connection state and preferences.

pub fn capabilities(&self) -> &CapabilityManifest

Get the capability manifest

pub fn capabilities_mut(&mut self) -> &mut CapabilityManifest

Get a mutable reference to the capability manifest

pub fn connect(&mut self, endpoint: &str) -> Result<()>

Connect to a DCP server

If DCP connection fails and MCP fallback is available, will fall back to MCP.

pub fn disconnect(&mut self)

Disconnect from the server

pub fn register_tool( &mut self, name: &str, description: &str, schema_hash: [u8; 32], capabilities: u64, ) -> u32

Register a tool

pub fn get_tool(&self, id: u32) -> Option<&ToolDefinition>

Get a registered tool by ID

pub fn list_tools(&self) -> Vec<&ToolDefinition>

List all registered tools

pub fn invoke_tool(&self, tool_id: u32, args: &[u8]) -> Result<Vec<u8>>

Invoke a tool via DCP binary protocol

Uses Zero-Copy Tool Invocation (ZCTI) for maximum performance.

pub fn encode_message( &self, message_type: MessageType, payload: &[u8], ) -> Vec<u8>

Encode a DCP message with BME envelope

pub fn decode_message(&self, bytes: &[u8]) -> Result<DcpMessage>

Decode a DCP message from bytes

pub fn create_tool_message( &self, tool_id: u32, args: &[u8], ) -> Result<DcpMessage>

Create a tool invocation message

pub fn create_resource_message(&self, resource_uri: &str) -> DcpMessage

Create a resource request message

pub fn create_prompt_message(&self, prompt: &str) -> DcpMessage

Create a prompt message

pub fn create_response_message(&self, response: &[u8]) -> DcpMessage

Create a response message

pub fn create_error_message( &self, error_code: u32, error_msg: &str, ) -> DcpMessage

Create an error message

pub fn create_stream_builder(&self, chunk_size: usize) -> StreamBuilder

Create a streaming message builder

pub fn create_stream_assembler(&self) -> StreamAssembler

Create a stream assembler for receiving chunked data

pub fn create_zcti_builder(&self, tool_id: u32) -> Result<ZctiBuilder>

Create a ZCTI builder for the given tool

pub fn invoke_tool_zcti(&self, builder: ZctiBuilder) -> Result<Vec<u8>>

Invoke a tool using ZCTI (Zero-Copy Tool Invocation)

pub fn parse_tool_invocation<'a>( &self, message: &'a DcpMessage, ) -> Result<ZctiReader<'a>>

Parse a tool invocation from a received message

pub fn create_shared_buffer(&self, capacity: usize) -> SharedArgBuffer

Create a shared argument buffer

pub fn mcp_adapter(&self) -> Option<&McpAdapter>

Get the MCP adapter for JSON-RPC compatibility

pub fn mcp_adapter_mut(&mut self) -> Option<&mut McpAdapter>

Get a mutable reference to the MCP adapter

pub fn register_tool_mcp(&mut self, name: &str, tool_id: u32)

Register a tool with the MCP adapter for JSON-RPC compatibility

pub fn handle_mcp_request(&self, json: &str) -> Result<String>

Handle an MCP JSON-RPC request and return a JSON-RPC response

This provides seamless fallback to MCP when DCP is unavailable.

pub fn has_mcp_fallback(&self) -> bool

Check if MCP fallback is available

pub fn dcp_to_mcp(&self, message: &DcpMessage) -> Result<String>

Convert a DCP message to MCP JSON-RPC format

pub fn mcp_to_dcp(&self, json: &str) -> Result<DcpMessage>

Convert an MCP JSON-RPC request to DCP message

pub fn invoke_tool_mcp(&self, request: &str) -> Result<String>

Invoke a tool via MCP JSON-RPC protocol

Used as fallback when DCP is unavailable.

pub fn sign_tool_def(&self, tool_id: u32) -> Result<SignedToolDef>

Create a signed tool definition

pub fn verify_tool_def(&self, def: &SignedToolDef) -> Result<()>

Verify a signed tool definition

pub fn sign_invocation( &self, tool_id: u32, nonce: u64, timestamp: u64, args: &[u8], ) -> Result<SignedInvocation>

Sign a tool invocation

Creates a signed invocation that can be verified by the server. Requires signing to be enabled.

pub fn verify_invocation( &self, inv: &SignedInvocation, public_key: &[u8; 32], ) -> Result<()>

Verify a signed invocation

Verifies that the invocation was signed by the holder of the given public key.

pub fn verify_args_hash(&self, inv: &SignedInvocation, args: &[u8]) -> bool

Verify that the args hash in a signed invocation matches the provided arguments

pub fn generate_signer() -> Signer

Generate a random signer (for testing or ephemeral keys)

pub fn parse_capability_manifest(bytes: &[u8]) -> Result<&CapabilityManifest>

Parse a capability manifest from bytes

This is used when receiving a capability manifest from a remote server during capability negotiation.

pub fn serialize_capabilities(&self) -> Vec<u8>

Serialize the current capability manifest to bytes

pub fn register_resource(&mut self, resource_id: u16)

Register a resource in the capability manifest

pub fn unregister_resource(&mut self, resource_id: u16)

Unregister a resource from the capability manifest

pub fn has_resource(&self, resource_id: u16) -> bool

Check if a resource is registered

pub fn register_prompt(&mut self, prompt_id: u16)

Register a prompt in the capability manifest

pub fn unregister_prompt(&mut self, prompt_id: u16)

Unregister a prompt from the capability manifest

pub fn has_prompt(&self, prompt_id: u16) -> bool

Check if a prompt is registered

pub fn set_extension(&mut self, bit: u8)

Set an extension flag in the capability manifest

pub fn clear_extension(&mut self, bit: u8)

Clear an extension flag from the capability manifest

pub fn has_extension(&self, bit: u8) -> bool

Check if an extension is enabled

pub fn enforce_tool(&self, tool_id: u32) -> Result<()>

Enforce that a tool is available before invocation

Returns an error if the tool is not registered in the capability manifest.

pub fn enforce_resource(&self, resource_id: u16) -> Result<()>

Enforce that a resource is available before access

Returns an error if the resource is not registered in the capability manifest.

pub fn enforce_prompt(&self, prompt_id: u16) -> Result<()>

Enforce that a prompt is available before use

Returns an error if the prompt is not registered in the capability manifest.

pub fn negotiate_capabilities( &mut self, server_manifest: &CapabilityManifest, ) -> CapabilityManifest

Negotiate capabilities with a remote server

Takes the server’s capability manifest and computes the intersection, updating the local capabilities to only include mutually supported features.

pub fn capability_stats(&self) -> CapabilityStats

Get statistics about the current capabilities

pub fn tool_ids(&self) -> impl Iterator<Item = u16> + '_

Get an iterator over all registered tool IDs

pub fn resource_ids(&self) -> impl Iterator<Item = u16> + '_

Get an iterator over all registered resource IDs

pub fn prompt_ids(&self) -> impl Iterator<Item = u16> + '_

Get an iterator over all registered prompt IDs

pub fn intersect_capabilities( &self, other: &CapabilityManifest, ) -> CapabilityManifest

Compute capability intersection with another manifest

pub fn enable_signing(&mut self, seed: [u8; 32])

Enable signing with a seed

pub fn disable_signing(&mut self)

Disable signing

pub fn public_key(&self) -> Option<[u8; 32]>

Get the public key if signing is enabled