vtcode-mcp 0.140.0

Model Context Protocol (MCP) client, connection pooling, and tool discovery for VT Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Core MCP data types for tool, resource, and prompt information.

use rmcp::model::{ElicitationAction, PromptArgument, PromptMessage, ResourceContents};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};

/// Information about an MCP tool exposed by a provider.
#[derive(Debug, Clone)]
pub struct McpToolInfo {
    pub name: String,
    pub description: String,
    pub provider: String,
    pub input_schema: Value,
}

/// Summary of an MCP resource exposed by a provider.
#[derive(Debug, Clone)]
pub struct McpResourceInfo {
    pub(crate) provider: String,
    pub(crate) uri: String,
    pub(crate) name: String,
    pub(crate) description: Option<String>,
    pub(crate) mime_type: Option<String>,
    pub(crate) size: Option<i64>,
}

/// Resource contents fetched from an MCP provider.
#[derive(Debug, Clone)]
pub struct McpResourceData {
    pub(crate) provider: String,
    pub(crate) uri: String,
    pub(crate) contents: Vec<ResourceContents>,
    pub(crate) meta: Map<String, Value>,
}

/// Summary of an MCP prompt exposed by a provider.
#[derive(Debug, Clone)]
pub struct McpPromptInfo {
    pub(crate) provider: String,
    pub(crate) name: String,
    pub(crate) description: Option<String>,
    pub(crate) arguments: Vec<PromptArgument>,
}

/// Fully rendered MCP prompt ready for use.
#[derive(Debug, Clone)]
pub struct McpPromptDetail {
    pub(crate) provider: String,
    pub(crate) name: String,
    pub(crate) description: Option<String>,
    pub(crate) messages: Vec<PromptMessage>,
    pub(crate) meta: Map<String, Value>,
}

/// Snapshot describing the MCP client at runtime.
#[derive(Debug, Clone)]
pub struct McpClientStatus {
    pub enabled: bool,
    pub provider_count: usize,
    pub active_connections: usize,
    pub configured_providers: Vec<String>,
}

/// Request payload for handling elicitation prompts from MCP providers.
#[derive(Debug, Clone)]
pub struct McpElicitationRequest {
    pub message: String,
    pub requested_schema: Value,
    pub(crate) meta: Option<Value>,
}

/// Result returned by an elicitation handler after interacting with the user.
#[derive(Debug, Clone)]
pub struct McpElicitationResponse {
    pub action: ElicitationAction,
    pub content: Option<Value>,
    pub meta: Option<Value>,
}

// === File Upload Types (PR #15197) ===

/// Metadata key used in tool input schemas to indicate file upload parameters.
pub const OPENAI_FILE_PARAMS_META_KEY: &str = "_meta";
pub const OPENAI_FILE_PARAMS_VALUE: &str = "openai/fileParams";

/// Shape of a file payload provided by the client after upload.
///
/// This is the object shape that MCP tools expecting file uploads expect to receive.
/// The client uploads local files to the backend and replaces the local file path
/// with this structure.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProvidedFilePayload {
    /// The file ID returned from the upload (maps to backend file reference)
    #[serde(rename = "fileId")]
    file_id: String,
    /// The original file name
    #[serde(rename = "fileName")]
    file_name: String,
    /// MIME type of the uploaded file
    #[serde(rename = "mimeType")]
    mime_type: String,
    /// File size in bytes
    #[serde(rename = "fileSize")]
    file_size: i64,
}

/// Result of uploading a local file to the backend.
#[derive(Debug, Clone)]
pub struct FileUploadResult {
    /// The file ID from the backend upload
    file_id: String,
    /// The payload to substitute in the tool call arguments
    payload: ProvidedFilePayload,
}

/// Masked schema entry for a file parameter in a tool's input schema.
///
/// When a tool declares `_meta["openai/fileParams"]` in its input schema,
/// we mask the raw file payload object and instead instruct the model to
/// provide an absolute local file path. The client then handles the upload
/// and argument rewriting transparently.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileParamSchemaEntry {
    /// The original property name in the tool's input schema
    property_name: String,
    /// Description shown to the model for this file parameter
    description: String,
    /// Whether this file parameter is required
    required: bool,
}