Skip to main content

gproxy_protocol/protocol/claude/common/server_tools/
response_payloads.rs

1use serde::{Deserialize, Serialize};
2
3use super::super::{
4    Base64PdfSource, DocumentBlockType, JsonObject, PlainTextSource, ResponseToolReferenceBlock,
5    StopReason,
6};
7use super::{
8    TextEditorCodeExecutionFileType, TextEditorCodeExecutionStrReplaceResultBlockType,
9    TextEditorCodeExecutionToolResultErrorCode, TextEditorCodeExecutionToolResultErrorType,
10    TextEditorCodeExecutionViewResultBlockType, ToolSearchToolResultErrorCode,
11    ToolSearchToolResultErrorType,
12};
13
14#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
15pub struct ResponseWebFetchResultBlock {
16    pub content: ResponseWebFetchDocumentBlock,
17    pub retrieved_at: String,
18    #[serde(rename = "type")]
19    pub type_: ResponseWebFetchResultBlockType,
20    pub url: String,
21    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
22    pub extra: JsonObject,
23}
24
25#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
26pub enum ResponseWebFetchResultBlockType {
27    #[serde(rename = "web_fetch_result")]
28    WebFetchResult,
29}
30
31#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
32pub struct ResponseWebFetchDocumentBlock {
33    pub citations: ResponseWebFetchCitationConfig,
34    pub source: ResponseWebFetchDocumentSource,
35    pub title: String,
36    #[serde(rename = "type")]
37    pub type_: DocumentBlockType,
38    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
39    pub extra: JsonObject,
40}
41
42#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct ResponseWebFetchCitationConfig {
44    pub enabled: bool,
45    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
46    pub extra: JsonObject,
47}
48
49#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50#[serde(untagged)]
51pub enum ResponseWebFetchDocumentSource {
52    Base64(Base64PdfSource),
53    Text(PlainTextSource),
54}
55
56#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
57pub struct ResponseAdvisorResultBlock {
58    pub stop_reason: StopReason,
59    pub text: String,
60    #[serde(rename = "type")]
61    pub type_: ResponseAdvisorResultBlockType,
62    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
63    pub extra: JsonObject,
64}
65
66#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
67pub enum ResponseAdvisorResultBlockType {
68    #[serde(rename = "advisor_result")]
69    AdvisorResult,
70}
71
72#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
73pub struct ResponseAdvisorRedactedResultBlock {
74    pub encrypted_content: String,
75    pub stop_reason: StopReason,
76    #[serde(rename = "type")]
77    pub type_: ResponseAdvisorRedactedResultBlockType,
78    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
79    pub extra: JsonObject,
80}
81
82#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
83pub enum ResponseAdvisorRedactedResultBlockType {
84    #[serde(rename = "advisor_redacted_result")]
85    AdvisorRedactedResult,
86}
87
88#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
89pub struct ResponseTextEditorCodeExecutionViewResultBlock {
90    pub content: String,
91    pub file_type: TextEditorCodeExecutionFileType,
92    pub num_lines: u64,
93    pub start_line: u64,
94    pub total_lines: u64,
95    #[serde(rename = "type")]
96    pub type_: TextEditorCodeExecutionViewResultBlockType,
97    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
98    pub extra: JsonObject,
99}
100
101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
102pub struct ResponseTextEditorCodeExecutionStrReplaceResultBlock {
103    pub lines: Vec<String>,
104    pub new_lines: u64,
105    pub new_start: u64,
106    pub old_lines: u64,
107    pub old_start: u64,
108    #[serde(rename = "type")]
109    pub type_: TextEditorCodeExecutionStrReplaceResultBlockType,
110    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
111    pub extra: JsonObject,
112}
113
114pub type ResponseTextEditorCodeExecutionToolResultError = ResponseServerToolResultError<
115    TextEditorCodeExecutionToolResultErrorCode,
116    TextEditorCodeExecutionToolResultErrorType,
117>;
118
119pub type ResponseToolSearchToolResultError =
120    ResponseServerToolResultError<ToolSearchToolResultErrorCode, ToolSearchToolResultErrorType>;
121
122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
123pub struct ResponseServerToolResultError<C, T> {
124    pub error_code: C,
125    pub error_message: String,
126    #[serde(rename = "type")]
127    pub type_: T,
128    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
129    pub extra: JsonObject,
130}
131
132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
133pub struct ResponseToolSearchToolSearchResultBlock {
134    pub tool_references: Vec<ResponseToolReferenceBlock>,
135    #[serde(rename = "type")]
136    pub type_: ResponseToolSearchToolSearchResultBlockType,
137    #[serde(default, flatten, skip_serializing_if = "JsonObject::is_empty")]
138    pub extra: JsonObject,
139}
140
141#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
142pub enum ResponseToolSearchToolSearchResultBlockType {
143    #[serde(rename = "tool_search_tool_search_result")]
144    ToolSearchToolSearchResult,
145}