1use crate::app::{AgentToolRef, OperationAnnotations, RequestContext};
6use crate::codec::agent::{
7 from_wire_agent_interaction, from_wire_agent_provider_capabilities, from_wire_agent_session,
8 from_wire_agent_turn, from_wire_list_agent_provider_interactions_response,
9 from_wire_list_agent_provider_sessions_response,
10 from_wire_list_agent_provider_turn_events_response,
11 from_wire_list_agent_provider_turns_response, to_wire_cancel_agent_provider_turn_request,
12 to_wire_create_agent_provider_session_request, to_wire_create_agent_provider_turn_request,
13 to_wire_get_agent_provider_capabilities_request,
14 to_wire_get_agent_provider_interaction_request, to_wire_get_agent_provider_session_request,
15 to_wire_get_agent_provider_turn_request, to_wire_list_agent_provider_interactions_request,
16 to_wire_list_agent_provider_sessions_request, to_wire_list_agent_provider_turn_events_request,
17 to_wire_list_agent_provider_turns_request, to_wire_resolve_agent_provider_interaction_request,
18 to_wire_update_agent_provider_session_request,
19};
20use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
21use crate::generated::v1;
22use crate::rpc_support::GestaltError;
23
24pub type AgentExecutionStatus = i32;
26
27pub mod agent_execution_status {
29 pub const AGENT_EXECUTION_STATUS_UNSPECIFIED: i32 = 0;
31 pub const AGENT_EXECUTION_STATUS_PENDING: i32 = 1;
33 pub const AGENT_EXECUTION_STATUS_RUNNING: i32 = 2;
35 pub const AGENT_EXECUTION_STATUS_SUCCEEDED: i32 = 3;
37 pub const AGENT_EXECUTION_STATUS_FAILED: i32 = 4;
39 pub const AGENT_EXECUTION_STATUS_CANCELED: i32 = 5;
41 pub const AGENT_EXECUTION_STATUS_WAITING_FOR_INPUT: i32 = 6;
43}
44
45pub type AgentInteractionState = i32;
47
48pub mod agent_interaction_state {
50 pub const AGENT_INTERACTION_STATE_UNSPECIFIED: i32 = 0;
52 pub const AGENT_INTERACTION_STATE_PENDING: i32 = 1;
54 pub const AGENT_INTERACTION_STATE_RESOLVED: i32 = 2;
56 pub const AGENT_INTERACTION_STATE_CANCELED: i32 = 3;
58}
59
60pub type AgentInteractionType = i32;
62
63pub mod agent_interaction_type {
65 pub const AGENT_INTERACTION_TYPE_UNSPECIFIED: i32 = 0;
67 pub const AGENT_INTERACTION_TYPE_APPROVAL: i32 = 1;
69 pub const AGENT_INTERACTION_TYPE_CLARIFICATION: i32 = 2;
71 pub const AGENT_INTERACTION_TYPE_INPUT: i32 = 3;
73}
74
75pub type AgentMessagePartType = i32;
77
78pub mod agent_message_part_type {
80 pub const AGENT_MESSAGE_PART_TYPE_UNSPECIFIED: i32 = 0;
82 pub const AGENT_MESSAGE_PART_TYPE_TEXT: i32 = 1;
84 pub const AGENT_MESSAGE_PART_TYPE_JSON: i32 = 2;
86 pub const AGENT_MESSAGE_PART_TYPE_TOOL_CALL: i32 = 3;
88 pub const AGENT_MESSAGE_PART_TYPE_TOOL_RESULT: i32 = 4;
90 pub const AGENT_MESSAGE_PART_TYPE_IMAGE_REF: i32 = 5;
92}
93
94pub type AgentSessionState = i32;
96
97pub mod agent_session_state {
99 pub const AGENT_SESSION_STATE_UNSPECIFIED: i32 = 0;
101 pub const AGENT_SESSION_STATE_ACTIVE: i32 = 1;
103 pub const AGENT_SESSION_STATE_ARCHIVED: i32 = 2;
105}
106
107pub type AgentToolSourceMode = i32;
109
110pub mod agent_tool_source_mode {
112 pub const AGENT_TOOL_SOURCE_MODE_UNSPECIFIED: i32 = 0;
114 pub const AGENT_TOOL_SOURCE_MODE_CATALOG: i32 = 2;
116 pub const AGENT_TOOL_SOURCE_MODE_NONE: i32 = 3;
118}
119
120#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
122#[serde(rename_all = "camelCase")]
123pub struct AgentCatalogToolConfig {
124 pub refs: Vec<AgentToolRef>,
126 pub tools: Vec<ListedAgentTool>,
128}
129
130#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
132#[serde(rename_all = "camelCase")]
133pub struct AgentInteraction {
134 pub id: String,
136 pub r#type: AgentInteractionType,
138 pub state: AgentInteractionState,
140 pub title: String,
142 pub prompt: String,
144 pub request: Option<serde_json::Map<String, serde_json::Value>>,
146 pub resolution: Option<serde_json::Map<String, serde_json::Value>>,
148 #[serde(with = "crate::serde_time")]
149 pub created_at: Option<std::time::SystemTime>,
151 #[serde(with = "crate::serde_time")]
152 pub resolved_at: Option<std::time::SystemTime>,
154 pub turn_id: String,
156 pub session_id: String,
158}
159
160#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
162#[serde(rename_all = "camelCase")]
163pub struct AgentMessage {
164 pub role: String,
166 pub text: String,
168 pub parts: Vec<AgentMessagePart>,
170 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
172}
173
174#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
176#[serde(rename_all = "camelCase")]
177pub struct AgentMessagePart {
178 pub r#type: AgentMessagePartType,
180 pub text: String,
182 pub json: Option<serde_json::Map<String, serde_json::Value>>,
184 pub tool_call: Option<AgentMessagePartToolCall>,
186 pub tool_result: Option<AgentMessagePartToolResult>,
188 pub image_ref: Option<AgentMessagePartImageRef>,
190}
191
192#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
194#[serde(rename_all = "camelCase")]
195pub struct AgentMessagePartImageRef {
196 pub uri: String,
198 pub mime_type: String,
200}
201
202#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
204#[serde(rename_all = "camelCase")]
205pub struct AgentMessagePartToolCall {
206 pub id: String,
208 pub tool_id: String,
210 pub arguments: Option<serde_json::Map<String, serde_json::Value>>,
212}
213
214#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
216#[serde(rename_all = "camelCase")]
217pub struct AgentMessagePartToolResult {
218 pub tool_call_id: String,
220 pub status: i32,
222 pub content: String,
224 pub output: Option<serde_json::Map<String, serde_json::Value>>,
226}
227
228#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
230#[serde(rename_all = "camelCase")]
231pub struct AgentNoTools {}
232
233#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
235#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
236pub enum AgentOutputKind {
237 Text(AgentTextOutput),
239 Structured(AgentStructuredOutput),
241}
242
243#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
245#[serde(rename_all = "camelCase")]
246pub struct AgentOutput {
247 pub kind: Option<AgentOutputKind>,
249}
250
251#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
253#[serde(rename_all = "camelCase")]
254pub struct AgentProviderCapabilities {
255 pub streaming_text: bool,
257 pub tool_calls: bool,
259 pub parallel_tool_calls: bool,
261 pub interactions: bool,
263 pub resumable_turns: bool,
265 pub reasoning_summaries: bool,
267 pub bounded_list_hydration: bool,
273 pub supported_tool_sources: Vec<AgentToolSourceMode>,
275 pub supports_session_start: bool,
277 pub supports_prepared_workspace: bool,
279}
280
281#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
283#[serde(rename_all = "camelCase")]
284pub struct AgentSession {
285 pub id: String,
287 pub provider_name: String,
289 pub model: String,
291 pub client_ref: String,
293 pub state: AgentSessionState,
295 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
297 pub created_by_subject_id: String,
299 #[serde(with = "crate::serde_time")]
300 pub created_at: Option<std::time::SystemTime>,
302 #[serde(with = "crate::serde_time")]
303 pub updated_at: Option<std::time::SystemTime>,
305 #[serde(with = "crate::serde_time")]
306 pub last_turn_at: Option<std::time::SystemTime>,
308}
309
310#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
312#[serde(rename_all = "camelCase")]
313pub struct AgentSessionStartConfig {
314 pub hooks: Vec<AgentSessionStartHook>,
316}
317
318#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
320#[serde(rename_all = "camelCase")]
321pub struct AgentSessionStartHook {
322 pub id: String,
324 pub r#type: String,
326 pub command: Vec<String>,
328 pub cwd: String,
330 pub timeout: String,
332 pub env: std::collections::BTreeMap<String, String>,
334 pub output: Option<AgentSessionStartHookOutput>,
336}
337
338#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
340#[serde(rename_all = "camelCase")]
341pub struct AgentSessionStartHookOutput {
342 pub additional_context: bool,
344 pub metadata: bool,
346}
347
348#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
350#[serde(rename_all = "camelCase")]
351pub struct AgentStructuredOutput {
352 pub schema: Option<serde_json::Map<String, serde_json::Value>>,
354}
355
356#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
358#[serde(rename_all = "camelCase")]
359pub struct AgentTextOutput {}
360
361#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
363#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
364pub enum AgentToolConfigSource {
365 None(AgentNoTools),
367 Catalog(AgentCatalogToolConfig),
369}
370
371#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
373#[serde(rename_all = "camelCase")]
374pub struct AgentToolConfig {
375 pub source: Option<AgentToolConfigSource>,
377}
378
379#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
381#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
382pub enum AgentTurnOutput {
383 Text(AgentTurnTextOutput),
385 Structured(AgentTurnStructuredOutput),
387}
388
389#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
391#[serde(rename_all = "camelCase")]
392pub struct AgentTurn {
393 pub id: String,
395 pub session_id: String,
397 pub provider_name: String,
399 pub model: String,
401 pub status: AgentExecutionStatus,
403 pub messages: Vec<AgentMessage>,
405 pub status_message: String,
407 pub created_by_subject_id: String,
409 #[serde(with = "crate::serde_time")]
410 pub created_at: Option<std::time::SystemTime>,
412 #[serde(with = "crate::serde_time")]
413 pub started_at: Option<std::time::SystemTime>,
415 #[serde(with = "crate::serde_time")]
416 pub completed_at: Option<std::time::SystemTime>,
418 pub execution_ref: String,
420 pub output: Option<AgentTurnOutput>,
422}
423
424#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
426#[serde(rename_all = "camelCase")]
427pub struct AgentTurnDisplay {
428 pub kind: String,
430 pub phase: String,
432 pub text: String,
434 pub label: String,
436 pub r#ref: String,
438 pub parent_ref: String,
440 pub input: Option<serde_json::Value>,
442 pub output: Option<serde_json::Value>,
444 pub error: Option<serde_json::Value>,
446 pub action: String,
448 pub format: String,
450 pub language: String,
452}
453
454#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
456#[serde(rename_all = "camelCase")]
457pub struct AgentTurnEvent {
458 pub id: String,
460 pub turn_id: String,
462 pub seq: i64,
464 pub r#type: String,
466 pub source: String,
468 pub visibility: String,
470 pub data: Option<serde_json::Map<String, serde_json::Value>>,
472 #[serde(with = "crate::serde_time")]
473 pub created_at: Option<std::time::SystemTime>,
475 pub display: Option<AgentTurnDisplay>,
477}
478
479#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
481#[serde(rename_all = "camelCase")]
482pub struct AgentTurnStructuredOutput {
483 pub text: String,
485 pub value: Option<serde_json::Map<String, serde_json::Value>>,
487}
488
489#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
491#[serde(rename_all = "camelCase")]
492pub struct AgentTurnTextOutput {
493 pub text: String,
495}
496
497#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
499#[serde(rename_all = "camelCase")]
500pub struct AgentWorkspace {
501 pub checkouts: Vec<AgentWorkspaceGitCheckout>,
503 pub cwd: String,
505}
506
507#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
509#[serde(rename_all = "camelCase")]
510pub struct AgentWorkspaceGitCheckout {
511 pub url: String,
513 pub r#ref: String,
515 pub path: String,
517}
518
519#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
521#[serde(rename_all = "camelCase")]
522pub struct CancelAgentProviderTurnRequest {
523 pub turn_id: String,
525 pub reason: String,
527 pub context: Option<RequestContext>,
529 pub provider_name: String,
531 pub session_id: String,
533}
534
535#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
537#[serde(rename_all = "camelCase")]
538pub struct CreateAgentProviderSessionRequest {
539 pub idempotency_key: String,
546 pub model: String,
548 pub client_ref: String,
550 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
552 pub session_start: Option<AgentSessionStartConfig>,
554 pub prepared_workspace: Option<PreparedAgentWorkspace>,
556 pub provider_name: String,
558 pub workspace: Option<AgentWorkspace>,
560 pub context: Option<RequestContext>,
562 pub tools: Option<AgentToolConfig>,
564}
565
566#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
568#[serde(rename_all = "camelCase")]
569pub struct CreateAgentProviderTurnRequest {
570 pub turn_id: String,
572 pub session_id: String,
574 pub idempotency_key: String,
576 pub model: String,
578 pub messages: Vec<AgentMessage>,
580 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
582 pub execution_ref: String,
584 pub model_options: Option<serde_json::Map<String, serde_json::Value>>,
586 pub timeout_seconds: i32,
592 pub output: Option<AgentOutput>,
594 pub context: Option<RequestContext>,
596 pub provider_name: String,
598}
599
600#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
602#[serde(rename_all = "camelCase")]
603pub struct GetAgentProviderCapabilitiesRequest {}
604
605#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
607#[serde(rename_all = "camelCase")]
608pub struct GetAgentProviderInteractionRequest {
609 pub interaction_id: String,
611 pub context: Option<RequestContext>,
613}
614
615#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
617#[serde(rename_all = "camelCase")]
618pub struct GetAgentProviderSessionRequest {
619 pub session_id: String,
621 pub context: Option<RequestContext>,
623 pub provider_name: String,
625}
626
627#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
629#[serde(rename_all = "camelCase")]
630pub struct GetAgentProviderTurnRequest {
631 pub turn_id: String,
633 pub context: Option<RequestContext>,
635 pub provider_name: String,
637 pub session_id: String,
639}
640
641#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
643#[serde(rename_all = "camelCase")]
644pub struct ListAgentProviderInteractionsRequest {
645 pub turn_id: String,
647 pub context: Option<RequestContext>,
649 pub provider_name: String,
651}
652
653#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
655#[serde(rename_all = "camelCase")]
656pub struct ListAgentProviderInteractionsResponse {
657 pub interactions: Vec<AgentInteraction>,
659}
660
661#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
663#[serde(rename_all = "camelCase")]
664pub struct ListAgentProviderSessionsRequest {
665 pub session_ids: Vec<String>,
667 pub state: AgentSessionState,
669 pub limit: i32,
674 pub summary_only: bool,
679 pub provider_name: String,
681 pub context: Option<RequestContext>,
683}
684
685#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
687#[serde(rename_all = "camelCase")]
688pub struct ListAgentProviderSessionsResponse {
689 pub sessions: Vec<AgentSession>,
691}
692
693#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
695#[serde(rename_all = "camelCase")]
696pub struct ListAgentProviderTurnEventsRequest {
697 pub turn_id: String,
699 pub after_seq: i64,
701 pub limit: i32,
703 pub context: Option<RequestContext>,
705 pub provider_name: String,
707 pub session_id: String,
709}
710
711#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
713#[serde(rename_all = "camelCase")]
714pub struct ListAgentProviderTurnEventsResponse {
715 pub events: Vec<AgentTurnEvent>,
717}
718
719#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
721#[serde(rename_all = "camelCase")]
722pub struct ListAgentProviderTurnsRequest {
723 pub session_id: String,
725 pub turn_ids: Vec<String>,
727 pub status: AgentExecutionStatus,
729 pub limit: i32,
734 pub summary_only: bool,
740 pub context: Option<RequestContext>,
742 pub provider_name: String,
744}
745
746#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
748#[serde(rename_all = "camelCase")]
749pub struct ListAgentProviderTurnsResponse {
750 pub turns: Vec<AgentTurn>,
752}
753
754#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
756#[serde(rename_all = "camelCase")]
757pub struct ListedAgentTool {
758 pub id: String,
760 pub mcp_name: String,
762 pub title: String,
764 pub description: String,
766 pub input_schema: String,
768 pub output_schema: String,
770 pub annotations: Option<OperationAnnotations>,
772 pub r#ref: Option<AgentToolRef>,
774 pub tags: Vec<String>,
776 pub search_text: String,
778}
779
780#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
782#[serde(rename_all = "camelCase")]
783pub struct PreparedAgentWorkspace {
784 pub root: String,
786 pub cwd: String,
788}
789
790#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
792#[serde(rename_all = "camelCase")]
793pub struct ResolveAgentProviderInteractionRequest {
794 pub interaction_id: String,
796 pub resolution: Option<serde_json::Map<String, serde_json::Value>>,
798 pub turn_id: String,
800 pub context: Option<RequestContext>,
802 pub provider_name: String,
804}
805
806#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
808#[serde(rename_all = "camelCase")]
809pub struct UpdateAgentProviderSessionRequest {
810 pub session_id: String,
812 pub client_ref: String,
814 pub state: AgentSessionState,
816 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
818 pub context: Option<RequestContext>,
820 pub provider_name: String,
822}
823
824pub struct Agent {
831 inner: v1::agent_client::AgentClient<HostServiceChannel>,
832 timeout: Option<std::time::Duration>,
833 context: Option<RequestContext>,
834}
835
836impl Agent {
837 pub fn new(channel: tonic::transport::Channel) -> Self {
839 Self {
840 inner: v1::agent_client::AgentClient::new(plain_channel(channel)),
841 timeout: None,
842 context: None,
843 }
844 }
845
846 pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
849 self.timeout = Some(timeout);
850 self
851 }
852
853 pub fn with_context(mut self, context: RequestContext) -> Self {
856 self.context = Some(context);
857 self
858 }
859
860 pub async fn connect() -> Result<Self, GestaltError> {
862 Self::connect_named("").await
863 }
864
865 pub async fn connect_named(name: &str) -> Result<Self, GestaltError> {
867 Ok(Self {
868 inner: v1::agent_client::AgentClient::new(connect_host_service("agent", name).await?),
869 timeout: None,
870 context: None,
871 })
872 }
873
874 pub async fn create_session(
876 &mut self,
877 idempotency_key: String,
878 model: String,
879 options: AgentCreateSessionOptions,
880 ) -> Result<AgentSession, GestaltError> {
881 let request = CreateAgentProviderSessionRequest {
882 idempotency_key,
883 model,
884 provider_name: options.provider_name,
885 client_ref: options.client_ref,
886 metadata: options.metadata,
887 workspace: options.workspace,
888 tools: options.tools,
889 context: self.context.clone(),
890 ..Default::default()
891 };
892 let mut tonic_request =
893 tonic::Request::new(to_wire_create_agent_provider_session_request(request));
894 if let Some(timeout) = self.timeout {
895 tonic_request.set_timeout(timeout);
896 }
897 let response = self.inner.create_session(tonic_request).await?;
898 Ok(from_wire_agent_session(response.into_inner()))
899 }
900
901 pub async fn create_session_raw(
903 &mut self,
904 request: CreateAgentProviderSessionRequest,
905 ) -> Result<AgentSession, GestaltError> {
906 let mut request = request;
907 if request.context.is_none() {
908 request.context = self.context.clone();
909 }
910 let mut tonic_request =
911 tonic::Request::new(to_wire_create_agent_provider_session_request(request));
912 if let Some(timeout) = self.timeout {
913 tonic_request.set_timeout(timeout);
914 }
915 let response = self.inner.create_session(tonic_request).await?;
916 Ok(from_wire_agent_session(response.into_inner()))
917 }
918
919 pub async fn get_session(
921 &mut self,
922 session_id: String,
923 options: AgentGetSessionOptions,
924 ) -> Result<AgentSession, GestaltError> {
925 let request = GetAgentProviderSessionRequest {
926 session_id,
927 provider_name: options.provider_name,
928 context: self.context.clone(),
929 };
930 let mut tonic_request =
931 tonic::Request::new(to_wire_get_agent_provider_session_request(request));
932 if let Some(timeout) = self.timeout {
933 tonic_request.set_timeout(timeout);
934 }
935 let response = self.inner.get_session(tonic_request).await?;
936 Ok(from_wire_agent_session(response.into_inner()))
937 }
938
939 pub async fn get_session_raw(
941 &mut self,
942 request: GetAgentProviderSessionRequest,
943 ) -> Result<AgentSession, GestaltError> {
944 let mut request = request;
945 if request.context.is_none() {
946 request.context = self.context.clone();
947 }
948 let mut tonic_request =
949 tonic::Request::new(to_wire_get_agent_provider_session_request(request));
950 if let Some(timeout) = self.timeout {
951 tonic_request.set_timeout(timeout);
952 }
953 let response = self.inner.get_session(tonic_request).await?;
954 Ok(from_wire_agent_session(response.into_inner()))
955 }
956
957 pub async fn list_sessions(
959 &mut self,
960 options: AgentListSessionsOptions,
961 ) -> Result<Vec<AgentSession>, GestaltError> {
962 let request = ListAgentProviderSessionsRequest {
963 session_ids: options.session_ids,
964 state: options.state,
965 limit: options.limit,
966 summary_only: options.summary_only,
967 provider_name: options.provider_name,
968 context: self.context.clone(),
969 };
970 let mut tonic_request =
971 tonic::Request::new(to_wire_list_agent_provider_sessions_request(request));
972 if let Some(timeout) = self.timeout {
973 tonic_request.set_timeout(timeout);
974 }
975 let response = from_wire_list_agent_provider_sessions_response(
976 self.inner.list_sessions(tonic_request).await?.into_inner(),
977 );
978 Ok(response.sessions)
979 }
980
981 pub async fn list_sessions_raw(
983 &mut self,
984 request: ListAgentProviderSessionsRequest,
985 ) -> Result<ListAgentProviderSessionsResponse, GestaltError> {
986 let mut request = request;
987 if request.context.is_none() {
988 request.context = self.context.clone();
989 }
990 let mut tonic_request =
991 tonic::Request::new(to_wire_list_agent_provider_sessions_request(request));
992 if let Some(timeout) = self.timeout {
993 tonic_request.set_timeout(timeout);
994 }
995 let response = self.inner.list_sessions(tonic_request).await?;
996 Ok(from_wire_list_agent_provider_sessions_response(
997 response.into_inner(),
998 ))
999 }
1000
1001 pub async fn update_session(
1003 &mut self,
1004 session_id: String,
1005 options: AgentUpdateSessionOptions,
1006 ) -> Result<AgentSession, GestaltError> {
1007 let request = UpdateAgentProviderSessionRequest {
1008 session_id,
1009 client_ref: options.client_ref,
1010 state: options.state,
1011 provider_name: options.provider_name,
1012 metadata: options.metadata,
1013 context: self.context.clone(),
1014 };
1015 let mut tonic_request =
1016 tonic::Request::new(to_wire_update_agent_provider_session_request(request));
1017 if let Some(timeout) = self.timeout {
1018 tonic_request.set_timeout(timeout);
1019 }
1020 let response = self.inner.update_session(tonic_request).await?;
1021 Ok(from_wire_agent_session(response.into_inner()))
1022 }
1023
1024 pub async fn update_session_raw(
1026 &mut self,
1027 request: UpdateAgentProviderSessionRequest,
1028 ) -> Result<AgentSession, GestaltError> {
1029 let mut request = request;
1030 if request.context.is_none() {
1031 request.context = self.context.clone();
1032 }
1033 let mut tonic_request =
1034 tonic::Request::new(to_wire_update_agent_provider_session_request(request));
1035 if let Some(timeout) = self.timeout {
1036 tonic_request.set_timeout(timeout);
1037 }
1038 let response = self.inner.update_session(tonic_request).await?;
1039 Ok(from_wire_agent_session(response.into_inner()))
1040 }
1041
1042 pub async fn create_turn(
1044 &mut self,
1045 session_id: String,
1046 idempotency_key: String,
1047 model: String,
1048 messages: Vec<AgentMessage>,
1049 options: AgentCreateTurnOptions,
1050 ) -> Result<AgentTurn, GestaltError> {
1051 let request = CreateAgentProviderTurnRequest {
1052 session_id,
1053 idempotency_key,
1054 model,
1055 messages,
1056 execution_ref: options.execution_ref,
1057 timeout_seconds: options.timeout_seconds,
1058 provider_name: options.provider_name,
1059 metadata: options.metadata,
1060 model_options: options.model_options,
1061 output: options.output,
1062 context: self.context.clone(),
1063 ..Default::default()
1064 };
1065 let mut tonic_request =
1066 tonic::Request::new(to_wire_create_agent_provider_turn_request(request));
1067 if let Some(timeout) = self.timeout {
1068 tonic_request.set_timeout(timeout);
1069 }
1070 let response = self.inner.create_turn(tonic_request).await?;
1071 Ok(from_wire_agent_turn(response.into_inner()))
1072 }
1073
1074 pub async fn create_turn_raw(
1076 &mut self,
1077 request: CreateAgentProviderTurnRequest,
1078 ) -> Result<AgentTurn, GestaltError> {
1079 let mut request = request;
1080 if request.context.is_none() {
1081 request.context = self.context.clone();
1082 }
1083 let mut tonic_request =
1084 tonic::Request::new(to_wire_create_agent_provider_turn_request(request));
1085 if let Some(timeout) = self.timeout {
1086 tonic_request.set_timeout(timeout);
1087 }
1088 let response = self.inner.create_turn(tonic_request).await?;
1089 Ok(from_wire_agent_turn(response.into_inner()))
1090 }
1091
1092 pub async fn get_turn(
1094 &mut self,
1095 turn_id: String,
1096 options: AgentGetTurnOptions,
1097 ) -> Result<AgentTurn, GestaltError> {
1098 let request = GetAgentProviderTurnRequest {
1099 turn_id,
1100 provider_name: options.provider_name,
1101 context: self.context.clone(),
1102 ..Default::default()
1103 };
1104 let mut tonic_request =
1105 tonic::Request::new(to_wire_get_agent_provider_turn_request(request));
1106 if let Some(timeout) = self.timeout {
1107 tonic_request.set_timeout(timeout);
1108 }
1109 let response = self.inner.get_turn(tonic_request).await?;
1110 Ok(from_wire_agent_turn(response.into_inner()))
1111 }
1112
1113 pub async fn get_turn_raw(
1115 &mut self,
1116 request: GetAgentProviderTurnRequest,
1117 ) -> Result<AgentTurn, GestaltError> {
1118 let mut request = request;
1119 if request.context.is_none() {
1120 request.context = self.context.clone();
1121 }
1122 let mut tonic_request =
1123 tonic::Request::new(to_wire_get_agent_provider_turn_request(request));
1124 if let Some(timeout) = self.timeout {
1125 tonic_request.set_timeout(timeout);
1126 }
1127 let response = self.inner.get_turn(tonic_request).await?;
1128 Ok(from_wire_agent_turn(response.into_inner()))
1129 }
1130
1131 pub async fn list_turns(
1133 &mut self,
1134 session_id: String,
1135 options: AgentListTurnsOptions,
1136 ) -> Result<Vec<AgentTurn>, GestaltError> {
1137 let request = ListAgentProviderTurnsRequest {
1138 session_id,
1139 turn_ids: options.turn_ids,
1140 status: options.status,
1141 limit: options.limit,
1142 summary_only: options.summary_only,
1143 provider_name: options.provider_name,
1144 context: self.context.clone(),
1145 };
1146 let mut tonic_request =
1147 tonic::Request::new(to_wire_list_agent_provider_turns_request(request));
1148 if let Some(timeout) = self.timeout {
1149 tonic_request.set_timeout(timeout);
1150 }
1151 let response = from_wire_list_agent_provider_turns_response(
1152 self.inner.list_turns(tonic_request).await?.into_inner(),
1153 );
1154 Ok(response.turns)
1155 }
1156
1157 pub async fn list_turns_raw(
1159 &mut self,
1160 request: ListAgentProviderTurnsRequest,
1161 ) -> Result<ListAgentProviderTurnsResponse, GestaltError> {
1162 let mut request = request;
1163 if request.context.is_none() {
1164 request.context = self.context.clone();
1165 }
1166 let mut tonic_request =
1167 tonic::Request::new(to_wire_list_agent_provider_turns_request(request));
1168 if let Some(timeout) = self.timeout {
1169 tonic_request.set_timeout(timeout);
1170 }
1171 let response = self.inner.list_turns(tonic_request).await?;
1172 Ok(from_wire_list_agent_provider_turns_response(
1173 response.into_inner(),
1174 ))
1175 }
1176
1177 pub async fn cancel_turn(
1179 &mut self,
1180 turn_id: String,
1181 options: AgentCancelTurnOptions,
1182 ) -> Result<AgentTurn, GestaltError> {
1183 let request = CancelAgentProviderTurnRequest {
1184 turn_id,
1185 reason: options.reason,
1186 provider_name: options.provider_name,
1187 context: self.context.clone(),
1188 ..Default::default()
1189 };
1190 let mut tonic_request =
1191 tonic::Request::new(to_wire_cancel_agent_provider_turn_request(request));
1192 if let Some(timeout) = self.timeout {
1193 tonic_request.set_timeout(timeout);
1194 }
1195 let response = self.inner.cancel_turn(tonic_request).await?;
1196 Ok(from_wire_agent_turn(response.into_inner()))
1197 }
1198
1199 pub async fn cancel_turn_raw(
1201 &mut self,
1202 request: CancelAgentProviderTurnRequest,
1203 ) -> Result<AgentTurn, GestaltError> {
1204 let mut request = request;
1205 if request.context.is_none() {
1206 request.context = self.context.clone();
1207 }
1208 let mut tonic_request =
1209 tonic::Request::new(to_wire_cancel_agent_provider_turn_request(request));
1210 if let Some(timeout) = self.timeout {
1211 tonic_request.set_timeout(timeout);
1212 }
1213 let response = self.inner.cancel_turn(tonic_request).await?;
1214 Ok(from_wire_agent_turn(response.into_inner()))
1215 }
1216
1217 pub async fn list_turn_events(
1219 &mut self,
1220 turn_id: String,
1221 options: AgentListTurnEventsOptions,
1222 ) -> Result<Vec<AgentTurnEvent>, GestaltError> {
1223 let request = ListAgentProviderTurnEventsRequest {
1224 turn_id,
1225 after_seq: options.after_seq,
1226 limit: options.limit,
1227 provider_name: options.provider_name,
1228 context: self.context.clone(),
1229 ..Default::default()
1230 };
1231 let mut tonic_request =
1232 tonic::Request::new(to_wire_list_agent_provider_turn_events_request(request));
1233 if let Some(timeout) = self.timeout {
1234 tonic_request.set_timeout(timeout);
1235 }
1236 let response = from_wire_list_agent_provider_turn_events_response(
1237 self.inner
1238 .list_turn_events(tonic_request)
1239 .await?
1240 .into_inner(),
1241 );
1242 Ok(response.events)
1243 }
1244
1245 pub async fn list_turn_events_raw(
1247 &mut self,
1248 request: ListAgentProviderTurnEventsRequest,
1249 ) -> Result<ListAgentProviderTurnEventsResponse, GestaltError> {
1250 let mut request = request;
1251 if request.context.is_none() {
1252 request.context = self.context.clone();
1253 }
1254 let mut tonic_request =
1255 tonic::Request::new(to_wire_list_agent_provider_turn_events_request(request));
1256 if let Some(timeout) = self.timeout {
1257 tonic_request.set_timeout(timeout);
1258 }
1259 let response = self.inner.list_turn_events(tonic_request).await?;
1260 Ok(from_wire_list_agent_provider_turn_events_response(
1261 response.into_inner(),
1262 ))
1263 }
1264
1265 pub async fn get_interaction(
1267 &mut self,
1268 interaction_id: String,
1269 ) -> Result<AgentInteraction, GestaltError> {
1270 let request = GetAgentProviderInteractionRequest {
1271 interaction_id,
1272 context: self.context.clone(),
1273 };
1274 let mut tonic_request =
1275 tonic::Request::new(to_wire_get_agent_provider_interaction_request(request));
1276 if let Some(timeout) = self.timeout {
1277 tonic_request.set_timeout(timeout);
1278 }
1279 let response = self.inner.get_interaction(tonic_request).await?;
1280 Ok(from_wire_agent_interaction(response.into_inner()))
1281 }
1282
1283 pub async fn get_interaction_raw(
1285 &mut self,
1286 request: GetAgentProviderInteractionRequest,
1287 ) -> Result<AgentInteraction, GestaltError> {
1288 let mut request = request;
1289 if request.context.is_none() {
1290 request.context = self.context.clone();
1291 }
1292 let mut tonic_request =
1293 tonic::Request::new(to_wire_get_agent_provider_interaction_request(request));
1294 if let Some(timeout) = self.timeout {
1295 tonic_request.set_timeout(timeout);
1296 }
1297 let response = self.inner.get_interaction(tonic_request).await?;
1298 Ok(from_wire_agent_interaction(response.into_inner()))
1299 }
1300
1301 pub async fn list_interactions(
1303 &mut self,
1304 turn_id: String,
1305 options: AgentListInteractionsOptions,
1306 ) -> Result<Vec<AgentInteraction>, GestaltError> {
1307 let request = ListAgentProviderInteractionsRequest {
1308 turn_id,
1309 provider_name: options.provider_name,
1310 context: self.context.clone(),
1311 };
1312 let mut tonic_request =
1313 tonic::Request::new(to_wire_list_agent_provider_interactions_request(request));
1314 if let Some(timeout) = self.timeout {
1315 tonic_request.set_timeout(timeout);
1316 }
1317 let response = from_wire_list_agent_provider_interactions_response(
1318 self.inner
1319 .list_interactions(tonic_request)
1320 .await?
1321 .into_inner(),
1322 );
1323 Ok(response.interactions)
1324 }
1325
1326 pub async fn list_interactions_raw(
1328 &mut self,
1329 request: ListAgentProviderInteractionsRequest,
1330 ) -> Result<ListAgentProviderInteractionsResponse, GestaltError> {
1331 let mut request = request;
1332 if request.context.is_none() {
1333 request.context = self.context.clone();
1334 }
1335 let mut tonic_request =
1336 tonic::Request::new(to_wire_list_agent_provider_interactions_request(request));
1337 if let Some(timeout) = self.timeout {
1338 tonic_request.set_timeout(timeout);
1339 }
1340 let response = self.inner.list_interactions(tonic_request).await?;
1341 Ok(from_wire_list_agent_provider_interactions_response(
1342 response.into_inner(),
1343 ))
1344 }
1345
1346 pub async fn resolve_interaction(
1348 &mut self,
1349 interaction_id: String,
1350 turn_id: String,
1351 resolution: Option<serde_json::Map<String, serde_json::Value>>,
1352 options: AgentResolveInteractionOptions,
1353 ) -> Result<AgentInteraction, GestaltError> {
1354 let request = ResolveAgentProviderInteractionRequest {
1355 interaction_id,
1356 turn_id,
1357 resolution,
1358 provider_name: options.provider_name,
1359 context: self.context.clone(),
1360 };
1361 let mut tonic_request =
1362 tonic::Request::new(to_wire_resolve_agent_provider_interaction_request(request));
1363 if let Some(timeout) = self.timeout {
1364 tonic_request.set_timeout(timeout);
1365 }
1366 let response = self.inner.resolve_interaction(tonic_request).await?;
1367 Ok(from_wire_agent_interaction(response.into_inner()))
1368 }
1369
1370 pub async fn resolve_interaction_raw(
1372 &mut self,
1373 request: ResolveAgentProviderInteractionRequest,
1374 ) -> Result<AgentInteraction, GestaltError> {
1375 let mut request = request;
1376 if request.context.is_none() {
1377 request.context = self.context.clone();
1378 }
1379 let mut tonic_request =
1380 tonic::Request::new(to_wire_resolve_agent_provider_interaction_request(request));
1381 if let Some(timeout) = self.timeout {
1382 tonic_request.set_timeout(timeout);
1383 }
1384 let response = self.inner.resolve_interaction(tonic_request).await?;
1385 Ok(from_wire_agent_interaction(response.into_inner()))
1386 }
1387
1388 pub async fn get_capabilities(
1390 &mut self,
1391 request: GetAgentProviderCapabilitiesRequest,
1392 ) -> Result<AgentProviderCapabilities, GestaltError> {
1393 let mut tonic_request =
1394 tonic::Request::new(to_wire_get_agent_provider_capabilities_request(request));
1395 if let Some(timeout) = self.timeout {
1396 tonic_request.set_timeout(timeout);
1397 }
1398 let response = self.inner.get_capabilities(tonic_request).await?;
1399 Ok(from_wire_agent_provider_capabilities(response.into_inner()))
1400 }
1401}
1402
1403#[derive(Clone, Debug, Default)]
1406pub struct AgentCreateSessionOptions {
1407 pub provider_name: String,
1409 pub client_ref: String,
1411 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
1413 pub workspace: Option<AgentWorkspace>,
1415 pub tools: Option<AgentToolConfig>,
1417}
1418
1419#[derive(Clone, Debug, Default)]
1422pub struct AgentGetSessionOptions {
1423 pub provider_name: String,
1425}
1426
1427#[derive(Clone, Debug, Default)]
1430pub struct AgentListSessionsOptions {
1431 pub session_ids: Vec<String>,
1433 pub state: AgentSessionState,
1435 pub limit: i32,
1440 pub summary_only: bool,
1445 pub provider_name: String,
1447}
1448
1449#[derive(Clone, Debug, Default)]
1452pub struct AgentUpdateSessionOptions {
1453 pub client_ref: String,
1455 pub state: AgentSessionState,
1457 pub provider_name: String,
1459 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
1461}
1462
1463#[derive(Clone, Debug, Default)]
1466pub struct AgentCreateTurnOptions {
1467 pub execution_ref: String,
1469 pub timeout_seconds: i32,
1475 pub provider_name: String,
1477 pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
1479 pub model_options: Option<serde_json::Map<String, serde_json::Value>>,
1481 pub output: Option<AgentOutput>,
1483}
1484
1485#[derive(Clone, Debug, Default)]
1488pub struct AgentGetTurnOptions {
1489 pub provider_name: String,
1491}
1492
1493#[derive(Clone, Debug, Default)]
1496pub struct AgentListTurnsOptions {
1497 pub turn_ids: Vec<String>,
1499 pub status: AgentExecutionStatus,
1501 pub limit: i32,
1506 pub summary_only: bool,
1512 pub provider_name: String,
1514}
1515
1516#[derive(Clone, Debug, Default)]
1519pub struct AgentCancelTurnOptions {
1520 pub reason: String,
1522 pub provider_name: String,
1524}
1525
1526#[derive(Clone, Debug, Default)]
1529pub struct AgentListTurnEventsOptions {
1530 pub after_seq: i64,
1532 pub limit: i32,
1534 pub provider_name: String,
1536}
1537
1538#[derive(Clone, Debug, Default)]
1541pub struct AgentListInteractionsOptions {
1542 pub provider_name: String,
1544}
1545
1546#[derive(Clone, Debug, Default)]
1549pub struct AgentResolveInteractionOptions {
1550 pub provider_name: String,
1552}