// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v4.25.3
// source: agent-communication.proto

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

package protos

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// agent pinging the server
type AgentPing struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AgentId       string                 `protobuf:"bytes,1,opt,name=agentId,proto3" json:"agentId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentPing) Reset() {
	*x = AgentPing{}
	mi := &file_agent_communication_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentPing) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentPing) ProtoMessage() {}

func (x *AgentPing) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentPing.ProtoReflect.Descriptor instead.
func (*AgentPing) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{0}
}

func (x *AgentPing) GetAgentId() string {
	if x != nil {
		return x.AgentId
	}
	return ""
}

// server requesting the agent to shutdown
type ShutdownRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AgentId       string                 `protobuf:"bytes,1,opt,name=agentId,proto3" json:"agentId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ShutdownRequest) Reset() {
	*x = ShutdownRequest{}
	mi := &file_agent_communication_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ShutdownRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ShutdownRequest) ProtoMessage() {}

func (x *ShutdownRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ShutdownRequest.ProtoReflect.Descriptor instead.
func (*ShutdownRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{1}
}

func (x *ShutdownRequest) GetAgentId() string {
	if x != nil {
		return x.AgentId
	}
	return ""
}

// server requesting the agent to create a new agent subprocess
type CreateAgentRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	AgentId       string                 `protobuf:"bytes,2,opt,name=agentId,proto3" json:"agentId,omitempty"`
	ContainerId   string                 `protobuf:"bytes,3,opt,name=containerId,proto3" json:"containerId,omitempty"`
	WorkingDir    string                 `protobuf:"bytes,4,opt,name=workingDir,proto3" json:"workingDir,omitempty"`
	Mounts        []string               `protobuf:"bytes,5,rep,name=mounts,proto3" json:"mounts,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateAgentRequest) Reset() {
	*x = CreateAgentRequest{}
	mi := &file_agent_communication_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CreateAgentRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CreateAgentRequest) ProtoMessage() {}

func (x *CreateAgentRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CreateAgentRequest.ProtoReflect.Descriptor instead.
func (*CreateAgentRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{2}
}

func (x *CreateAgentRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *CreateAgentRequest) GetAgentId() string {
	if x != nil {
		return x.AgentId
	}
	return ""
}

func (x *CreateAgentRequest) GetContainerId() string {
	if x != nil {
		return x.ContainerId
	}
	return ""
}

func (x *CreateAgentRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *CreateAgentRequest) GetMounts() []string {
	if x != nil {
		return x.Mounts
	}
	return nil
}

type CreateAgentResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	AgentId       string                 `protobuf:"bytes,2,opt,name=agentId,proto3" json:"agentId,omitempty"`
	Status        string                 `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateAgentResponse) Reset() {
	*x = CreateAgentResponse{}
	mi := &file_agent_communication_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CreateAgentResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CreateAgentResponse) ProtoMessage() {}

func (x *CreateAgentResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CreateAgentResponse.ProtoReflect.Descriptor instead.
func (*CreateAgentResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{3}
}

func (x *CreateAgentResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *CreateAgentResponse) GetAgentId() string {
	if x != nil {
		return x.AgentId
	}
	return ""
}

func (x *CreateAgentResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

// server requesting the agent to terminate an agent subprocess
type TerminateAgentRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	AgentId       string                 `protobuf:"bytes,2,opt,name=agentId,proto3" json:"agentId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TerminateAgentRequest) Reset() {
	*x = TerminateAgentRequest{}
	mi := &file_agent_communication_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TerminateAgentRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TerminateAgentRequest) ProtoMessage() {}

func (x *TerminateAgentRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TerminateAgentRequest.ProtoReflect.Descriptor instead.
func (*TerminateAgentRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{4}
}

func (x *TerminateAgentRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *TerminateAgentRequest) GetAgentId() string {
	if x != nil {
		return x.AgentId
	}
	return ""
}

type TerminateAgentResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	AgentId       string                 `protobuf:"bytes,2,opt,name=agentId,proto3" json:"agentId,omitempty"`
	Status        string                 `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TerminateAgentResponse) Reset() {
	*x = TerminateAgentResponse{}
	mi := &file_agent_communication_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TerminateAgentResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TerminateAgentResponse) ProtoMessage() {}

func (x *TerminateAgentResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TerminateAgentResponse.ProtoReflect.Descriptor instead.
func (*TerminateAgentResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{5}
}

func (x *TerminateAgentResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *TerminateAgentResponse) GetAgentId() string {
	if x != nil {
		return x.AgentId
	}
	return ""
}

func (x *TerminateAgentResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

// server requesting the agent to setup an environment
type EnvSetupRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	EnvName       string                 `protobuf:"bytes,2,opt,name=envName,proto3" json:"envName,omitempty"`
	Libraries     []string               `protobuf:"bytes,3,rep,name=libraries,proto3" json:"libraries,omitempty"`
	Pip           []string               `protobuf:"bytes,4,rep,name=pip,proto3" json:"pip,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EnvSetupRequest) Reset() {
	*x = EnvSetupRequest{}
	mi := &file_agent_communication_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EnvSetupRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EnvSetupRequest) ProtoMessage() {}

func (x *EnvSetupRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EnvSetupRequest.ProtoReflect.Descriptor instead.
func (*EnvSetupRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{6}
}

func (x *EnvSetupRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *EnvSetupRequest) GetEnvName() string {
	if x != nil {
		return x.EnvName
	}
	return ""
}

func (x *EnvSetupRequest) GetLibraries() []string {
	if x != nil {
		return x.Libraries
	}
	return nil
}

func (x *EnvSetupRequest) GetPip() []string {
	if x != nil {
		return x.Pip
	}
	return nil
}

type EnvSetupResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	Status        string                 `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EnvSetupResponse) Reset() {
	*x = EnvSetupResponse{}
	mi := &file_agent_communication_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EnvSetupResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EnvSetupResponse) ProtoMessage() {}

func (x *EnvSetupResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EnvSetupResponse.ProtoReflect.Descriptor instead.
func (*EnvSetupResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{7}
}

func (x *EnvSetupResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *EnvSetupResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

// server requesting the agent to execute a shell command in the environment
type CommandExecutionRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	EnvName       string                 `protobuf:"bytes,2,opt,name=envName,proto3" json:"envName,omitempty"`
	WorkingDir    string                 `protobuf:"bytes,3,opt,name=workingDir,proto3" json:"workingDir,omitempty"`
	Arguments     []string               `protobuf:"bytes,4,rep,name=arguments,proto3" json:"arguments,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CommandExecutionRequest) Reset() {
	*x = CommandExecutionRequest{}
	mi := &file_agent_communication_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CommandExecutionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CommandExecutionRequest) ProtoMessage() {}

func (x *CommandExecutionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CommandExecutionRequest.ProtoReflect.Descriptor instead.
func (*CommandExecutionRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{8}
}

func (x *CommandExecutionRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *CommandExecutionRequest) GetEnvName() string {
	if x != nil {
		return x.EnvName
	}
	return ""
}

func (x *CommandExecutionRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *CommandExecutionRequest) GetArguments() []string {
	if x != nil {
		return x.Arguments
	}
	return nil
}

type CommandExecutionResponse struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId    string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	ResponseString string                 `protobuf:"bytes,2,opt,name=responseString,proto3" json:"responseString,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *CommandExecutionResponse) Reset() {
	*x = CommandExecutionResponse{}
	mi := &file_agent_communication_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CommandExecutionResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CommandExecutionResponse) ProtoMessage() {}

func (x *CommandExecutionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CommandExecutionResponse.ProtoReflect.Descriptor instead.
func (*CommandExecutionResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{9}
}

func (x *CommandExecutionResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *CommandExecutionResponse) GetResponseString() string {
	if x != nil {
		return x.ResponseString
	}
	return ""
}

type AsyncCommandExecutionRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	EnvName       string                 `protobuf:"bytes,2,opt,name=envName,proto3" json:"envName,omitempty"`
	WorkingDir    string                 `protobuf:"bytes,3,opt,name=workingDir,proto3" json:"workingDir,omitempty"`
	Arguments     []string               `protobuf:"bytes,4,rep,name=arguments,proto3" json:"arguments,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommandExecutionRequest) Reset() {
	*x = AsyncCommandExecutionRequest{}
	mi := &file_agent_communication_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommandExecutionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommandExecutionRequest) ProtoMessage() {}

func (x *AsyncCommandExecutionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommandExecutionRequest.ProtoReflect.Descriptor instead.
func (*AsyncCommandExecutionRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{10}
}

func (x *AsyncCommandExecutionRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *AsyncCommandExecutionRequest) GetEnvName() string {
	if x != nil {
		return x.EnvName
	}
	return ""
}

func (x *AsyncCommandExecutionRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *AsyncCommandExecutionRequest) GetArguments() []string {
	if x != nil {
		return x.Arguments
	}
	return nil
}

type AsyncCommandExecutionResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	ProcessId     int32                  `protobuf:"varint,2,opt,name=processId,proto3" json:"processId,omitempty"`
	ErrorMessage  string                 `protobuf:"bytes,3,opt,name=errorMessage,proto3" json:"errorMessage,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommandExecutionResponse) Reset() {
	*x = AsyncCommandExecutionResponse{}
	mi := &file_agent_communication_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommandExecutionResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommandExecutionResponse) ProtoMessage() {}

func (x *AsyncCommandExecutionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommandExecutionResponse.ProtoReflect.Descriptor instead.
func (*AsyncCommandExecutionResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{11}
}

func (x *AsyncCommandExecutionResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *AsyncCommandExecutionResponse) GetProcessId() int32 {
	if x != nil {
		return x.ProcessId
	}
	return 0
}

func (x *AsyncCommandExecutionResponse) GetErrorMessage() string {
	if x != nil {
		return x.ErrorMessage
	}
	return ""
}

type AsyncCommandListRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommandListRequest) Reset() {
	*x = AsyncCommandListRequest{}
	mi := &file_agent_communication_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommandListRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommandListRequest) ProtoMessage() {}

func (x *AsyncCommandListRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommandListRequest.ProtoReflect.Descriptor instead.
func (*AsyncCommandListRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{12}
}

func (x *AsyncCommandListRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

type AsyncCommand struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ProcessId     int32                  `protobuf:"varint,1,opt,name=processId,proto3" json:"processId,omitempty"`
	Arguments     []string               `protobuf:"bytes,4,rep,name=arguments,proto3" json:"arguments,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommand) Reset() {
	*x = AsyncCommand{}
	mi := &file_agent_communication_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommand) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommand) ProtoMessage() {}

func (x *AsyncCommand) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommand.ProtoReflect.Descriptor instead.
func (*AsyncCommand) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{13}
}

func (x *AsyncCommand) GetProcessId() int32 {
	if x != nil {
		return x.ProcessId
	}
	return 0
}

func (x *AsyncCommand) GetArguments() []string {
	if x != nil {
		return x.Arguments
	}
	return nil
}

type AsyncCommandListResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	Commands      []*AsyncCommand        `protobuf:"bytes,2,rep,name=commands,proto3" json:"commands,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommandListResponse) Reset() {
	*x = AsyncCommandListResponse{}
	mi := &file_agent_communication_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommandListResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommandListResponse) ProtoMessage() {}

func (x *AsyncCommandListResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommandListResponse.ProtoReflect.Descriptor instead.
func (*AsyncCommandListResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{14}
}

func (x *AsyncCommandListResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *AsyncCommandListResponse) GetCommands() []*AsyncCommand {
	if x != nil {
		return x.Commands
	}
	return nil
}

type AsyncCommandTerminateRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	ProcessId     int32                  `protobuf:"varint,2,opt,name=processId,proto3" json:"processId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommandTerminateRequest) Reset() {
	*x = AsyncCommandTerminateRequest{}
	mi := &file_agent_communication_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommandTerminateRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommandTerminateRequest) ProtoMessage() {}

func (x *AsyncCommandTerminateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommandTerminateRequest.ProtoReflect.Descriptor instead.
func (*AsyncCommandTerminateRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{15}
}

func (x *AsyncCommandTerminateRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *AsyncCommandTerminateRequest) GetProcessId() int32 {
	if x != nil {
		return x.ProcessId
	}
	return 0
}

type AsyncCommandTerminateResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	Status        string                 `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AsyncCommandTerminateResponse) Reset() {
	*x = AsyncCommandTerminateResponse{}
	mi := &file_agent_communication_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AsyncCommandTerminateResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AsyncCommandTerminateResponse) ProtoMessage() {}

func (x *AsyncCommandTerminateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AsyncCommandTerminateResponse.ProtoReflect.Descriptor instead.
func (*AsyncCommandTerminateResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{16}
}

func (x *AsyncCommandTerminateResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *AsyncCommandTerminateResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

// server requesting the agent to execute a python script in the environment
type PythonExecutionRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	EnvName       string                 `protobuf:"bytes,2,opt,name=envName,proto3" json:"envName,omitempty"`
	WorkingDir    string                 `protobuf:"bytes,3,opt,name=workingDir,proto3" json:"workingDir,omitempty"`
	Code          string                 `protobuf:"bytes,4,opt,name=code,proto3" json:"code,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PythonExecutionRequest) Reset() {
	*x = PythonExecutionRequest{}
	mi := &file_agent_communication_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PythonExecutionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PythonExecutionRequest) ProtoMessage() {}

func (x *PythonExecutionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PythonExecutionRequest.ProtoReflect.Descriptor instead.
func (*PythonExecutionRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{17}
}

func (x *PythonExecutionRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *PythonExecutionRequest) GetEnvName() string {
	if x != nil {
		return x.EnvName
	}
	return ""
}

func (x *PythonExecutionRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *PythonExecutionRequest) GetCode() string {
	if x != nil {
		return x.Code
	}
	return ""
}

type PythonExecutionResponse struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId    string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	ResponseString string                 `protobuf:"bytes,2,opt,name=responseString,proto3" json:"responseString,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *PythonExecutionResponse) Reset() {
	*x = PythonExecutionResponse{}
	mi := &file_agent_communication_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PythonExecutionResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PythonExecutionResponse) ProtoMessage() {}

func (x *PythonExecutionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PythonExecutionResponse.ProtoReflect.Descriptor instead.
func (*PythonExecutionResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{18}
}

func (x *PythonExecutionResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *PythonExecutionResponse) GetResponseString() string {
	if x != nil {
		return x.ResponseString
	}
	return ""
}

// server requesting the agent to execute a jupyter notebook cell in the environment
type JupyterExecutionRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	EnvName       string                 `protobuf:"bytes,2,opt,name=envName,proto3" json:"envName,omitempty"`
	Code          string                 `protobuf:"bytes,3,opt,name=code,proto3" json:"code,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *JupyterExecutionRequest) Reset() {
	*x = JupyterExecutionRequest{}
	mi := &file_agent_communication_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *JupyterExecutionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*JupyterExecutionRequest) ProtoMessage() {}

func (x *JupyterExecutionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use JupyterExecutionRequest.ProtoReflect.Descriptor instead.
func (*JupyterExecutionRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{19}
}

func (x *JupyterExecutionRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *JupyterExecutionRequest) GetEnvName() string {
	if x != nil {
		return x.EnvName
	}
	return ""
}

func (x *JupyterExecutionRequest) GetCode() string {
	if x != nil {
		return x.Code
	}
	return ""
}

type JupyterExecutionResponse struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId    string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	ResponseString string                 `protobuf:"bytes,2,opt,name=responseString,proto3" json:"responseString,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *JupyterExecutionResponse) Reset() {
	*x = JupyterExecutionResponse{}
	mi := &file_agent_communication_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *JupyterExecutionResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*JupyterExecutionResponse) ProtoMessage() {}

func (x *JupyterExecutionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use JupyterExecutionResponse.ProtoReflect.Descriptor instead.
func (*JupyterExecutionResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{20}
}

func (x *JupyterExecutionResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *JupyterExecutionResponse) GetResponseString() string {
	if x != nil {
		return x.ResponseString
	}
	return ""
}

// server requesting the agent to restart a jupyter kernel
type KernelRestartRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	EnvName       string                 `protobuf:"bytes,2,opt,name=envName,proto3" json:"envName,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KernelRestartRequest) Reset() {
	*x = KernelRestartRequest{}
	mi := &file_agent_communication_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KernelRestartRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KernelRestartRequest) ProtoMessage() {}

func (x *KernelRestartRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KernelRestartRequest.ProtoReflect.Descriptor instead.
func (*KernelRestartRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{21}
}

func (x *KernelRestartRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *KernelRestartRequest) GetEnvName() string {
	if x != nil {
		return x.EnvName
	}
	return ""
}

type KernelRestartResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	Status        string                 `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KernelRestartResponse) Reset() {
	*x = KernelRestartResponse{}
	mi := &file_agent_communication_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KernelRestartResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KernelRestartResponse) ProtoMessage() {}

func (x *KernelRestartResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KernelRestartResponse.ProtoReflect.Descriptor instead.
func (*KernelRestartResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{22}
}

func (x *KernelRestartResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *KernelRestartResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

// server requesting the agent to create a ssh tunnel
type TunnelCreationRequest struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId        string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	LocalPort          int32                  `protobuf:"varint,2,opt,name=localPort,proto3" json:"localPort,omitempty"`
	LocalBindHost      string                 `protobuf:"bytes,3,opt,name=localBindHost,proto3" json:"localBindHost,omitempty"`
	TunnelServerHost   string                 `protobuf:"bytes,4,opt,name=tunnelServerHost,proto3" json:"tunnelServerHost,omitempty"`
	TunnelServerPort   int32                  `protobuf:"varint,5,opt,name=tunnelServerPort,proto3" json:"tunnelServerPort,omitempty"`
	TunnelServerApiUrl string                 `protobuf:"bytes,6,opt,name=tunnelServerApiUrl,proto3" json:"tunnelServerApiUrl,omitempty"`
	TunnelServerToken  string                 `protobuf:"bytes,7,opt,name=tunnelServerToken,proto3" json:"tunnelServerToken,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *TunnelCreationRequest) Reset() {
	*x = TunnelCreationRequest{}
	mi := &file_agent_communication_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TunnelCreationRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TunnelCreationRequest) ProtoMessage() {}

func (x *TunnelCreationRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TunnelCreationRequest.ProtoReflect.Descriptor instead.
func (*TunnelCreationRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{23}
}

func (x *TunnelCreationRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *TunnelCreationRequest) GetLocalPort() int32 {
	if x != nil {
		return x.LocalPort
	}
	return 0
}

func (x *TunnelCreationRequest) GetLocalBindHost() string {
	if x != nil {
		return x.LocalBindHost
	}
	return ""
}

func (x *TunnelCreationRequest) GetTunnelServerHost() string {
	if x != nil {
		return x.TunnelServerHost
	}
	return ""
}

func (x *TunnelCreationRequest) GetTunnelServerPort() int32 {
	if x != nil {
		return x.TunnelServerPort
	}
	return 0
}

func (x *TunnelCreationRequest) GetTunnelServerApiUrl() string {
	if x != nil {
		return x.TunnelServerApiUrl
	}
	return ""
}

func (x *TunnelCreationRequest) GetTunnelServerToken() string {
	if x != nil {
		return x.TunnelServerToken
	}
	return ""
}

type TunnelCreationResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	Status        string                 `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	TunnelHost    string                 `protobuf:"bytes,3,opt,name=tunnelHost,proto3" json:"tunnelHost,omitempty"`
	TunnelPort    int32                  `protobuf:"varint,4,opt,name=tunnelPort,proto3" json:"tunnelPort,omitempty"`
	TunnelId      string                 `protobuf:"bytes,5,opt,name=tunnelId,proto3" json:"tunnelId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TunnelCreationResponse) Reset() {
	*x = TunnelCreationResponse{}
	mi := &file_agent_communication_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TunnelCreationResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TunnelCreationResponse) ProtoMessage() {}

func (x *TunnelCreationResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[24]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TunnelCreationResponse.ProtoReflect.Descriptor instead.
func (*TunnelCreationResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{24}
}

func (x *TunnelCreationResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *TunnelCreationResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

func (x *TunnelCreationResponse) GetTunnelHost() string {
	if x != nil {
		return x.TunnelHost
	}
	return ""
}

func (x *TunnelCreationResponse) GetTunnelPort() int32 {
	if x != nil {
		return x.TunnelPort
	}
	return 0
}

func (x *TunnelCreationResponse) GetTunnelId() string {
	if x != nil {
		return x.TunnelId
	}
	return ""
}

// server requesting the agent to terminate a ssh tunnel
type TunnelTerminationRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	TunnelId      string                 `protobuf:"bytes,2,opt,name=tunnelId,proto3" json:"tunnelId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TunnelTerminationRequest) Reset() {
	*x = TunnelTerminationRequest{}
	mi := &file_agent_communication_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TunnelTerminationRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TunnelTerminationRequest) ProtoMessage() {}

func (x *TunnelTerminationRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[25]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TunnelTerminationRequest.ProtoReflect.Descriptor instead.
func (*TunnelTerminationRequest) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{25}
}

func (x *TunnelTerminationRequest) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *TunnelTerminationRequest) GetTunnelId() string {
	if x != nil {
		return x.TunnelId
	}
	return ""
}

type TunnelTerminationResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExecutionId   string                 `protobuf:"bytes,1,opt,name=executionId,proto3" json:"executionId,omitempty"`
	Status        string                 `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TunnelTerminationResponse) Reset() {
	*x = TunnelTerminationResponse{}
	mi := &file_agent_communication_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TunnelTerminationResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TunnelTerminationResponse) ProtoMessage() {}

func (x *TunnelTerminationResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[26]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use TunnelTerminationResponse.ProtoReflect.Descriptor instead.
func (*TunnelTerminationResponse) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{26}
}

func (x *TunnelTerminationResponse) GetExecutionId() string {
	if x != nil {
		return x.ExecutionId
	}
	return ""
}

func (x *TunnelTerminationResponse) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type AgentMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Message:
	//
	//	*AgentMessage_AgentPing
	//	*AgentMessage_CreateAgentResponse
	//	*AgentMessage_TerminateAgentResponse
	//	*AgentMessage_EnvSetupResponse
	//	*AgentMessage_CommandExecutionResponse
	//	*AgentMessage_PythonExecutionResponse
	//	*AgentMessage_JupyterExecutionResponse
	//	*AgentMessage_KernelRestartResponse
	//	*AgentMessage_TunnelCreationResponse
	//	*AgentMessage_TunnelTerminationResponse
	//	*AgentMessage_AsyncCommandExecutionResponse
	//	*AgentMessage_AsyncCommandListResponse
	//	*AgentMessage_AsyncCommandTerminateResponse
	Message       isAgentMessage_Message `protobuf_oneof:"message"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentMessage) Reset() {
	*x = AgentMessage{}
	mi := &file_agent_communication_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentMessage) ProtoMessage() {}

func (x *AgentMessage) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[27]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentMessage.ProtoReflect.Descriptor instead.
func (*AgentMessage) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{27}
}

func (x *AgentMessage) GetMessage() isAgentMessage_Message {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *AgentMessage) GetAgentPing() *AgentPing {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_AgentPing); ok {
			return x.AgentPing
		}
	}
	return nil
}

func (x *AgentMessage) GetCreateAgentResponse() *CreateAgentResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_CreateAgentResponse); ok {
			return x.CreateAgentResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetTerminateAgentResponse() *TerminateAgentResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_TerminateAgentResponse); ok {
			return x.TerminateAgentResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetEnvSetupResponse() *EnvSetupResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_EnvSetupResponse); ok {
			return x.EnvSetupResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetCommandExecutionResponse() *CommandExecutionResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_CommandExecutionResponse); ok {
			return x.CommandExecutionResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetPythonExecutionResponse() *PythonExecutionResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_PythonExecutionResponse); ok {
			return x.PythonExecutionResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetJupyterExecutionResponse() *JupyterExecutionResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_JupyterExecutionResponse); ok {
			return x.JupyterExecutionResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetKernelRestartResponse() *KernelRestartResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_KernelRestartResponse); ok {
			return x.KernelRestartResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetTunnelCreationResponse() *TunnelCreationResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_TunnelCreationResponse); ok {
			return x.TunnelCreationResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetTunnelTerminationResponse() *TunnelTerminationResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_TunnelTerminationResponse); ok {
			return x.TunnelTerminationResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetAsyncCommandExecutionResponse() *AsyncCommandExecutionResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_AsyncCommandExecutionResponse); ok {
			return x.AsyncCommandExecutionResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetAsyncCommandListResponse() *AsyncCommandListResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_AsyncCommandListResponse); ok {
			return x.AsyncCommandListResponse
		}
	}
	return nil
}

func (x *AgentMessage) GetAsyncCommandTerminateResponse() *AsyncCommandTerminateResponse {
	if x != nil {
		if x, ok := x.Message.(*AgentMessage_AsyncCommandTerminateResponse); ok {
			return x.AsyncCommandTerminateResponse
		}
	}
	return nil
}

type isAgentMessage_Message interface {
	isAgentMessage_Message()
}

type AgentMessage_AgentPing struct {
	AgentPing *AgentPing `protobuf:"bytes,1,opt,name=agentPing,proto3,oneof"`
}

type AgentMessage_CreateAgentResponse struct {
	CreateAgentResponse *CreateAgentResponse `protobuf:"bytes,2,opt,name=createAgentResponse,proto3,oneof"`
}

type AgentMessage_TerminateAgentResponse struct {
	TerminateAgentResponse *TerminateAgentResponse `protobuf:"bytes,3,opt,name=terminateAgentResponse,proto3,oneof"`
}

type AgentMessage_EnvSetupResponse struct {
	EnvSetupResponse *EnvSetupResponse `protobuf:"bytes,4,opt,name=envSetupResponse,proto3,oneof"`
}

type AgentMessage_CommandExecutionResponse struct {
	CommandExecutionResponse *CommandExecutionResponse `protobuf:"bytes,5,opt,name=commandExecutionResponse,proto3,oneof"`
}

type AgentMessage_PythonExecutionResponse struct {
	PythonExecutionResponse *PythonExecutionResponse `protobuf:"bytes,6,opt,name=pythonExecutionResponse,proto3,oneof"`
}

type AgentMessage_JupyterExecutionResponse struct {
	JupyterExecutionResponse *JupyterExecutionResponse `protobuf:"bytes,7,opt,name=jupyterExecutionResponse,proto3,oneof"`
}

type AgentMessage_KernelRestartResponse struct {
	KernelRestartResponse *KernelRestartResponse `protobuf:"bytes,8,opt,name=kernelRestartResponse,proto3,oneof"`
}

type AgentMessage_TunnelCreationResponse struct {
	TunnelCreationResponse *TunnelCreationResponse `protobuf:"bytes,9,opt,name=tunnelCreationResponse,proto3,oneof"`
}

type AgentMessage_TunnelTerminationResponse struct {
	TunnelTerminationResponse *TunnelTerminationResponse `protobuf:"bytes,10,opt,name=tunnelTerminationResponse,proto3,oneof"`
}

type AgentMessage_AsyncCommandExecutionResponse struct {
	AsyncCommandExecutionResponse *AsyncCommandExecutionResponse `protobuf:"bytes,11,opt,name=asyncCommandExecutionResponse,proto3,oneof"`
}

type AgentMessage_AsyncCommandListResponse struct {
	AsyncCommandListResponse *AsyncCommandListResponse `protobuf:"bytes,12,opt,name=asyncCommandListResponse,proto3,oneof"`
}

type AgentMessage_AsyncCommandTerminateResponse struct {
	AsyncCommandTerminateResponse *AsyncCommandTerminateResponse `protobuf:"bytes,13,opt,name=asyncCommandTerminateResponse,proto3,oneof"`
}

func (*AgentMessage_AgentPing) isAgentMessage_Message() {}

func (*AgentMessage_CreateAgentResponse) isAgentMessage_Message() {}

func (*AgentMessage_TerminateAgentResponse) isAgentMessage_Message() {}

func (*AgentMessage_EnvSetupResponse) isAgentMessage_Message() {}

func (*AgentMessage_CommandExecutionResponse) isAgentMessage_Message() {}

func (*AgentMessage_PythonExecutionResponse) isAgentMessage_Message() {}

func (*AgentMessage_JupyterExecutionResponse) isAgentMessage_Message() {}

func (*AgentMessage_KernelRestartResponse) isAgentMessage_Message() {}

func (*AgentMessage_TunnelCreationResponse) isAgentMessage_Message() {}

func (*AgentMessage_TunnelTerminationResponse) isAgentMessage_Message() {}

func (*AgentMessage_AsyncCommandExecutionResponse) isAgentMessage_Message() {}

func (*AgentMessage_AsyncCommandListResponse) isAgentMessage_Message() {}

func (*AgentMessage_AsyncCommandTerminateResponse) isAgentMessage_Message() {}

type ServerMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Message:
	//
	//	*ServerMessage_ShutdownRequest
	//	*ServerMessage_CreateAgentRequest
	//	*ServerMessage_TerminateAgentRequest
	//	*ServerMessage_EnvSetupRequest
	//	*ServerMessage_CommandExecutionRequest
	//	*ServerMessage_PythonExecutionRequest
	//	*ServerMessage_JupyterExecutionRequest
	//	*ServerMessage_KernelRestartRequest
	//	*ServerMessage_TunnelCreationRequest
	//	*ServerMessage_TunnelTerminationRequest
	//	*ServerMessage_AsyncCommandExecutionRequest
	//	*ServerMessage_AsyncCommandListRequest
	//	*ServerMessage_AsyncCommandTerminateRequest
	Message       isServerMessage_Message `protobuf_oneof:"message"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ServerMessage) Reset() {
	*x = ServerMessage{}
	mi := &file_agent_communication_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ServerMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ServerMessage) ProtoMessage() {}

func (x *ServerMessage) ProtoReflect() protoreflect.Message {
	mi := &file_agent_communication_proto_msgTypes[28]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ServerMessage.ProtoReflect.Descriptor instead.
func (*ServerMessage) Descriptor() ([]byte, []int) {
	return file_agent_communication_proto_rawDescGZIP(), []int{28}
}

func (x *ServerMessage) GetMessage() isServerMessage_Message {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *ServerMessage) GetShutdownRequest() *ShutdownRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_ShutdownRequest); ok {
			return x.ShutdownRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetCreateAgentRequest() *CreateAgentRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_CreateAgentRequest); ok {
			return x.CreateAgentRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetTerminateAgentRequest() *TerminateAgentRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_TerminateAgentRequest); ok {
			return x.TerminateAgentRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetEnvSetupRequest() *EnvSetupRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_EnvSetupRequest); ok {
			return x.EnvSetupRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetCommandExecutionRequest() *CommandExecutionRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_CommandExecutionRequest); ok {
			return x.CommandExecutionRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetPythonExecutionRequest() *PythonExecutionRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_PythonExecutionRequest); ok {
			return x.PythonExecutionRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetJupyterExecutionRequest() *JupyterExecutionRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_JupyterExecutionRequest); ok {
			return x.JupyterExecutionRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetKernelRestartRequest() *KernelRestartRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_KernelRestartRequest); ok {
			return x.KernelRestartRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetTunnelCreationRequest() *TunnelCreationRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_TunnelCreationRequest); ok {
			return x.TunnelCreationRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetTunnelTerminationRequest() *TunnelTerminationRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_TunnelTerminationRequest); ok {
			return x.TunnelTerminationRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetAsyncCommandExecutionRequest() *AsyncCommandExecutionRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_AsyncCommandExecutionRequest); ok {
			return x.AsyncCommandExecutionRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetAsyncCommandListRequest() *AsyncCommandListRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_AsyncCommandListRequest); ok {
			return x.AsyncCommandListRequest
		}
	}
	return nil
}

func (x *ServerMessage) GetAsyncCommandTerminateRequest() *AsyncCommandTerminateRequest {
	if x != nil {
		if x, ok := x.Message.(*ServerMessage_AsyncCommandTerminateRequest); ok {
			return x.AsyncCommandTerminateRequest
		}
	}
	return nil
}

type isServerMessage_Message interface {
	isServerMessage_Message()
}

type ServerMessage_ShutdownRequest struct {
	ShutdownRequest *ShutdownRequest `protobuf:"bytes,1,opt,name=shutdownRequest,proto3,oneof"`
}

type ServerMessage_CreateAgentRequest struct {
	CreateAgentRequest *CreateAgentRequest `protobuf:"bytes,2,opt,name=createAgentRequest,proto3,oneof"`
}

type ServerMessage_TerminateAgentRequest struct {
	TerminateAgentRequest *TerminateAgentRequest `protobuf:"bytes,3,opt,name=terminateAgentRequest,proto3,oneof"`
}

type ServerMessage_EnvSetupRequest struct {
	EnvSetupRequest *EnvSetupRequest `protobuf:"bytes,4,opt,name=envSetupRequest,proto3,oneof"`
}

type ServerMessage_CommandExecutionRequest struct {
	CommandExecutionRequest *CommandExecutionRequest `protobuf:"bytes,5,opt,name=commandExecutionRequest,proto3,oneof"`
}

type ServerMessage_PythonExecutionRequest struct {
	PythonExecutionRequest *PythonExecutionRequest `protobuf:"bytes,6,opt,name=pythonExecutionRequest,proto3,oneof"`
}

type ServerMessage_JupyterExecutionRequest struct {
	JupyterExecutionRequest *JupyterExecutionRequest `protobuf:"bytes,7,opt,name=jupyterExecutionRequest,proto3,oneof"`
}

type ServerMessage_KernelRestartRequest struct {
	KernelRestartRequest *KernelRestartRequest `protobuf:"bytes,8,opt,name=kernelRestartRequest,proto3,oneof"`
}

type ServerMessage_TunnelCreationRequest struct {
	TunnelCreationRequest *TunnelCreationRequest `protobuf:"bytes,9,opt,name=tunnelCreationRequest,proto3,oneof"`
}

type ServerMessage_TunnelTerminationRequest struct {
	TunnelTerminationRequest *TunnelTerminationRequest `protobuf:"bytes,10,opt,name=tunnelTerminationRequest,proto3,oneof"`
}

type ServerMessage_AsyncCommandExecutionRequest struct {
	AsyncCommandExecutionRequest *AsyncCommandExecutionRequest `protobuf:"bytes,11,opt,name=asyncCommandExecutionRequest,proto3,oneof"`
}

type ServerMessage_AsyncCommandListRequest struct {
	AsyncCommandListRequest *AsyncCommandListRequest `protobuf:"bytes,12,opt,name=asyncCommandListRequest,proto3,oneof"`
}

type ServerMessage_AsyncCommandTerminateRequest struct {
	AsyncCommandTerminateRequest *AsyncCommandTerminateRequest `protobuf:"bytes,13,opt,name=asyncCommandTerminateRequest,proto3,oneof"`
}

func (*ServerMessage_ShutdownRequest) isServerMessage_Message() {}

func (*ServerMessage_CreateAgentRequest) isServerMessage_Message() {}

func (*ServerMessage_TerminateAgentRequest) isServerMessage_Message() {}

func (*ServerMessage_EnvSetupRequest) isServerMessage_Message() {}

func (*ServerMessage_CommandExecutionRequest) isServerMessage_Message() {}

func (*ServerMessage_PythonExecutionRequest) isServerMessage_Message() {}

func (*ServerMessage_JupyterExecutionRequest) isServerMessage_Message() {}

func (*ServerMessage_KernelRestartRequest) isServerMessage_Message() {}

func (*ServerMessage_TunnelCreationRequest) isServerMessage_Message() {}

func (*ServerMessage_TunnelTerminationRequest) isServerMessage_Message() {}

func (*ServerMessage_AsyncCommandExecutionRequest) isServerMessage_Message() {}

func (*ServerMessage_AsyncCommandListRequest) isServerMessage_Message() {}

func (*ServerMessage_AsyncCommandTerminateRequest) isServerMessage_Message() {}

var File_agent_communication_proto protoreflect.FileDescriptor

const file_agent_communication_proto_rawDesc = "" +
	"\n" +
	"\x19agent-communication.proto\x12\x19org.apache.airavata.agent\"%\n" +
	"\tAgentPing\x12\x18\n" +
	"\aagentId\x18\x01 \x01(\tR\aagentId\"+\n" +
	"\x0fShutdownRequest\x12\x18\n" +
	"\aagentId\x18\x01 \x01(\tR\aagentId\"\xaa\x01\n" +
	"\x12CreateAgentRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aagentId\x18\x02 \x01(\tR\aagentId\x12 \n" +
	"\vcontainerId\x18\x03 \x01(\tR\vcontainerId\x12\x1e\n" +
	"\n" +
	"workingDir\x18\x04 \x01(\tR\n" +
	"workingDir\x12\x16\n" +
	"\x06mounts\x18\x05 \x03(\tR\x06mounts\"i\n" +
	"\x13CreateAgentResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aagentId\x18\x02 \x01(\tR\aagentId\x12\x16\n" +
	"\x06status\x18\x03 \x01(\tR\x06status\"S\n" +
	"\x15TerminateAgentRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aagentId\x18\x02 \x01(\tR\aagentId\"l\n" +
	"\x16TerminateAgentResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aagentId\x18\x02 \x01(\tR\aagentId\x12\x16\n" +
	"\x06status\x18\x03 \x01(\tR\x06status\"}\n" +
	"\x0fEnvSetupRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aenvName\x18\x02 \x01(\tR\aenvName\x12\x1c\n" +
	"\tlibraries\x18\x03 \x03(\tR\tlibraries\x12\x10\n" +
	"\x03pip\x18\x04 \x03(\tR\x03pip\"L\n" +
	"\x10EnvSetupResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x16\n" +
	"\x06status\x18\x02 \x01(\tR\x06status\"\x93\x01\n" +
	"\x17CommandExecutionRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aenvName\x18\x02 \x01(\tR\aenvName\x12\x1e\n" +
	"\n" +
	"workingDir\x18\x03 \x01(\tR\n" +
	"workingDir\x12\x1c\n" +
	"\targuments\x18\x04 \x03(\tR\targuments\"d\n" +
	"\x18CommandExecutionResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12&\n" +
	"\x0eresponseString\x18\x02 \x01(\tR\x0eresponseString\"\x98\x01\n" +
	"\x1cAsyncCommandExecutionRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aenvName\x18\x02 \x01(\tR\aenvName\x12\x1e\n" +
	"\n" +
	"workingDir\x18\x03 \x01(\tR\n" +
	"workingDir\x12\x1c\n" +
	"\targuments\x18\x04 \x03(\tR\targuments\"\x83\x01\n" +
	"\x1dAsyncCommandExecutionResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x1c\n" +
	"\tprocessId\x18\x02 \x01(\x05R\tprocessId\x12\"\n" +
	"\ferrorMessage\x18\x03 \x01(\tR\ferrorMessage\";\n" +
	"\x17AsyncCommandListRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\"J\n" +
	"\fAsyncCommand\x12\x1c\n" +
	"\tprocessId\x18\x01 \x01(\x05R\tprocessId\x12\x1c\n" +
	"\targuments\x18\x04 \x03(\tR\targuments\"\x81\x01\n" +
	"\x18AsyncCommandListResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12C\n" +
	"\bcommands\x18\x02 \x03(\v2'.org.apache.airavata.agent.AsyncCommandR\bcommands\"^\n" +
	"\x1cAsyncCommandTerminateRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x1c\n" +
	"\tprocessId\x18\x02 \x01(\x05R\tprocessId\"Y\n" +
	"\x1dAsyncCommandTerminateResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x16\n" +
	"\x06status\x18\x02 \x01(\tR\x06status\"\x88\x01\n" +
	"\x16PythonExecutionRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aenvName\x18\x02 \x01(\tR\aenvName\x12\x1e\n" +
	"\n" +
	"workingDir\x18\x03 \x01(\tR\n" +
	"workingDir\x12\x12\n" +
	"\x04code\x18\x04 \x01(\tR\x04code\"c\n" +
	"\x17PythonExecutionResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12&\n" +
	"\x0eresponseString\x18\x02 \x01(\tR\x0eresponseString\"i\n" +
	"\x17JupyterExecutionRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aenvName\x18\x02 \x01(\tR\aenvName\x12\x12\n" +
	"\x04code\x18\x03 \x01(\tR\x04code\"d\n" +
	"\x18JupyterExecutionResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12&\n" +
	"\x0eresponseString\x18\x02 \x01(\tR\x0eresponseString\"R\n" +
	"\x14KernelRestartRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x18\n" +
	"\aenvName\x18\x02 \x01(\tR\aenvName\"Q\n" +
	"\x15KernelRestartResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x16\n" +
	"\x06status\x18\x02 \x01(\tR\x06status\"\xb3\x02\n" +
	"\x15TunnelCreationRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x1c\n" +
	"\tlocalPort\x18\x02 \x01(\x05R\tlocalPort\x12$\n" +
	"\rlocalBindHost\x18\x03 \x01(\tR\rlocalBindHost\x12*\n" +
	"\x10tunnelServerHost\x18\x04 \x01(\tR\x10tunnelServerHost\x12*\n" +
	"\x10tunnelServerPort\x18\x05 \x01(\x05R\x10tunnelServerPort\x12.\n" +
	"\x12tunnelServerApiUrl\x18\x06 \x01(\tR\x12tunnelServerApiUrl\x12,\n" +
	"\x11tunnelServerToken\x18\a \x01(\tR\x11tunnelServerToken\"\xae\x01\n" +
	"\x16TunnelCreationResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x16\n" +
	"\x06status\x18\x02 \x01(\tR\x06status\x12\x1e\n" +
	"\n" +
	"tunnelHost\x18\x03 \x01(\tR\n" +
	"tunnelHost\x12\x1e\n" +
	"\n" +
	"tunnelPort\x18\x04 \x01(\x05R\n" +
	"tunnelPort\x12\x1a\n" +
	"\btunnelId\x18\x05 \x01(\tR\btunnelId\"X\n" +
	"\x18TunnelTerminationRequest\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x1a\n" +
	"\btunnelId\x18\x02 \x01(\tR\btunnelId\"U\n" +
	"\x19TunnelTerminationResponse\x12 \n" +
	"\vexecutionId\x18\x01 \x01(\tR\vexecutionId\x12\x16\n" +
	"\x06status\x18\x02 \x01(\tR\x06status\"\xa7\v\n" +
	"\fAgentMessage\x12D\n" +
	"\tagentPing\x18\x01 \x01(\v2$.org.apache.airavata.agent.AgentPingH\x00R\tagentPing\x12b\n" +
	"\x13createAgentResponse\x18\x02 \x01(\v2..org.apache.airavata.agent.CreateAgentResponseH\x00R\x13createAgentResponse\x12k\n" +
	"\x16terminateAgentResponse\x18\x03 \x01(\v21.org.apache.airavata.agent.TerminateAgentResponseH\x00R\x16terminateAgentResponse\x12Y\n" +
	"\x10envSetupResponse\x18\x04 \x01(\v2+.org.apache.airavata.agent.EnvSetupResponseH\x00R\x10envSetupResponse\x12q\n" +
	"\x18commandExecutionResponse\x18\x05 \x01(\v23.org.apache.airavata.agent.CommandExecutionResponseH\x00R\x18commandExecutionResponse\x12n\n" +
	"\x17pythonExecutionResponse\x18\x06 \x01(\v22.org.apache.airavata.agent.PythonExecutionResponseH\x00R\x17pythonExecutionResponse\x12q\n" +
	"\x18jupyterExecutionResponse\x18\a \x01(\v23.org.apache.airavata.agent.JupyterExecutionResponseH\x00R\x18jupyterExecutionResponse\x12h\n" +
	"\x15kernelRestartResponse\x18\b \x01(\v20.org.apache.airavata.agent.KernelRestartResponseH\x00R\x15kernelRestartResponse\x12k\n" +
	"\x16tunnelCreationResponse\x18\t \x01(\v21.org.apache.airavata.agent.TunnelCreationResponseH\x00R\x16tunnelCreationResponse\x12t\n" +
	"\x19tunnelTerminationResponse\x18\n" +
	" \x01(\v24.org.apache.airavata.agent.TunnelTerminationResponseH\x00R\x19tunnelTerminationResponse\x12\x80\x01\n" +
	"\x1dasyncCommandExecutionResponse\x18\v \x01(\v28.org.apache.airavata.agent.AsyncCommandExecutionResponseH\x00R\x1dasyncCommandExecutionResponse\x12q\n" +
	"\x18asyncCommandListResponse\x18\f \x01(\v23.org.apache.airavata.agent.AsyncCommandListResponseH\x00R\x18asyncCommandListResponse\x12\x80\x01\n" +
	"\x1dasyncCommandTerminateResponse\x18\r \x01(\v28.org.apache.airavata.agent.AsyncCommandTerminateResponseH\x00R\x1dasyncCommandTerminateResponseB\t\n" +
	"\amessage\"\x94\v\n" +
	"\rServerMessage\x12V\n" +
	"\x0fshutdownRequest\x18\x01 \x01(\v2*.org.apache.airavata.agent.ShutdownRequestH\x00R\x0fshutdownRequest\x12_\n" +
	"\x12createAgentRequest\x18\x02 \x01(\v2-.org.apache.airavata.agent.CreateAgentRequestH\x00R\x12createAgentRequest\x12h\n" +
	"\x15terminateAgentRequest\x18\x03 \x01(\v20.org.apache.airavata.agent.TerminateAgentRequestH\x00R\x15terminateAgentRequest\x12V\n" +
	"\x0fenvSetupRequest\x18\x04 \x01(\v2*.org.apache.airavata.agent.EnvSetupRequestH\x00R\x0fenvSetupRequest\x12n\n" +
	"\x17commandExecutionRequest\x18\x05 \x01(\v22.org.apache.airavata.agent.CommandExecutionRequestH\x00R\x17commandExecutionRequest\x12k\n" +
	"\x16pythonExecutionRequest\x18\x06 \x01(\v21.org.apache.airavata.agent.PythonExecutionRequestH\x00R\x16pythonExecutionRequest\x12n\n" +
	"\x17jupyterExecutionRequest\x18\a \x01(\v22.org.apache.airavata.agent.JupyterExecutionRequestH\x00R\x17jupyterExecutionRequest\x12e\n" +
	"\x14kernelRestartRequest\x18\b \x01(\v2/.org.apache.airavata.agent.KernelRestartRequestH\x00R\x14kernelRestartRequest\x12h\n" +
	"\x15tunnelCreationRequest\x18\t \x01(\v20.org.apache.airavata.agent.TunnelCreationRequestH\x00R\x15tunnelCreationRequest\x12q\n" +
	"\x18tunnelTerminationRequest\x18\n" +
	" \x01(\v23.org.apache.airavata.agent.TunnelTerminationRequestH\x00R\x18tunnelTerminationRequest\x12}\n" +
	"\x1casyncCommandExecutionRequest\x18\v \x01(\v27.org.apache.airavata.agent.AsyncCommandExecutionRequestH\x00R\x1casyncCommandExecutionRequest\x12n\n" +
	"\x17asyncCommandListRequest\x18\f \x01(\v22.org.apache.airavata.agent.AsyncCommandListRequestH\x00R\x17asyncCommandListRequest\x12}\n" +
	"\x1casyncCommandTerminateRequest\x18\r \x01(\v27.org.apache.airavata.agent.AsyncCommandTerminateRequestH\x00R\x1casyncCommandTerminateRequestB\t\n" +
	"\amessage2\x86\x01\n" +
	"\x19AgentCommunicationService\x12i\n" +
	"\x10createMessageBus\x12'.org.apache.airavata.agent.AgentMessage\x1a(.org.apache.airavata.agent.ServerMessage(\x010\x01B?\n" +
	"\x19org.apache.airavata.agentB\x17AgentCommunicationProtoP\x01Z\aprotos/b\x06proto3"

var (
	file_agent_communication_proto_rawDescOnce sync.Once
	file_agent_communication_proto_rawDescData []byte
)

func file_agent_communication_proto_rawDescGZIP() []byte {
	file_agent_communication_proto_rawDescOnce.Do(func() {
		file_agent_communication_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agent_communication_proto_rawDesc), len(file_agent_communication_proto_rawDesc)))
	})
	return file_agent_communication_proto_rawDescData
}

var file_agent_communication_proto_msgTypes = make([]protoimpl.MessageInfo, 29)
var file_agent_communication_proto_goTypes = []any{
	(*AgentPing)(nil),                     // 0: org.apache.airavata.agent.AgentPing
	(*ShutdownRequest)(nil),               // 1: org.apache.airavata.agent.ShutdownRequest
	(*CreateAgentRequest)(nil),            // 2: org.apache.airavata.agent.CreateAgentRequest
	(*CreateAgentResponse)(nil),           // 3: org.apache.airavata.agent.CreateAgentResponse
	(*TerminateAgentRequest)(nil),         // 4: org.apache.airavata.agent.TerminateAgentRequest
	(*TerminateAgentResponse)(nil),        // 5: org.apache.airavata.agent.TerminateAgentResponse
	(*EnvSetupRequest)(nil),               // 6: org.apache.airavata.agent.EnvSetupRequest
	(*EnvSetupResponse)(nil),              // 7: org.apache.airavata.agent.EnvSetupResponse
	(*CommandExecutionRequest)(nil),       // 8: org.apache.airavata.agent.CommandExecutionRequest
	(*CommandExecutionResponse)(nil),      // 9: org.apache.airavata.agent.CommandExecutionResponse
	(*AsyncCommandExecutionRequest)(nil),  // 10: org.apache.airavata.agent.AsyncCommandExecutionRequest
	(*AsyncCommandExecutionResponse)(nil), // 11: org.apache.airavata.agent.AsyncCommandExecutionResponse
	(*AsyncCommandListRequest)(nil),       // 12: org.apache.airavata.agent.AsyncCommandListRequest
	(*AsyncCommand)(nil),                  // 13: org.apache.airavata.agent.AsyncCommand
	(*AsyncCommandListResponse)(nil),      // 14: org.apache.airavata.agent.AsyncCommandListResponse
	(*AsyncCommandTerminateRequest)(nil),  // 15: org.apache.airavata.agent.AsyncCommandTerminateRequest
	(*AsyncCommandTerminateResponse)(nil), // 16: org.apache.airavata.agent.AsyncCommandTerminateResponse
	(*PythonExecutionRequest)(nil),        // 17: org.apache.airavata.agent.PythonExecutionRequest
	(*PythonExecutionResponse)(nil),       // 18: org.apache.airavata.agent.PythonExecutionResponse
	(*JupyterExecutionRequest)(nil),       // 19: org.apache.airavata.agent.JupyterExecutionRequest
	(*JupyterExecutionResponse)(nil),      // 20: org.apache.airavata.agent.JupyterExecutionResponse
	(*KernelRestartRequest)(nil),          // 21: org.apache.airavata.agent.KernelRestartRequest
	(*KernelRestartResponse)(nil),         // 22: org.apache.airavata.agent.KernelRestartResponse
	(*TunnelCreationRequest)(nil),         // 23: org.apache.airavata.agent.TunnelCreationRequest
	(*TunnelCreationResponse)(nil),        // 24: org.apache.airavata.agent.TunnelCreationResponse
	(*TunnelTerminationRequest)(nil),      // 25: org.apache.airavata.agent.TunnelTerminationRequest
	(*TunnelTerminationResponse)(nil),     // 26: org.apache.airavata.agent.TunnelTerminationResponse
	(*AgentMessage)(nil),                  // 27: org.apache.airavata.agent.AgentMessage
	(*ServerMessage)(nil),                 // 28: org.apache.airavata.agent.ServerMessage
}
var file_agent_communication_proto_depIdxs = []int32{
	13, // 0: org.apache.airavata.agent.AsyncCommandListResponse.commands:type_name -> org.apache.airavata.agent.AsyncCommand
	0,  // 1: org.apache.airavata.agent.AgentMessage.agentPing:type_name -> org.apache.airavata.agent.AgentPing
	3,  // 2: org.apache.airavata.agent.AgentMessage.createAgentResponse:type_name -> org.apache.airavata.agent.CreateAgentResponse
	5,  // 3: org.apache.airavata.agent.AgentMessage.terminateAgentResponse:type_name -> org.apache.airavata.agent.TerminateAgentResponse
	7,  // 4: org.apache.airavata.agent.AgentMessage.envSetupResponse:type_name -> org.apache.airavata.agent.EnvSetupResponse
	9,  // 5: org.apache.airavata.agent.AgentMessage.commandExecutionResponse:type_name -> org.apache.airavata.agent.CommandExecutionResponse
	18, // 6: org.apache.airavata.agent.AgentMessage.pythonExecutionResponse:type_name -> org.apache.airavata.agent.PythonExecutionResponse
	20, // 7: org.apache.airavata.agent.AgentMessage.jupyterExecutionResponse:type_name -> org.apache.airavata.agent.JupyterExecutionResponse
	22, // 8: org.apache.airavata.agent.AgentMessage.kernelRestartResponse:type_name -> org.apache.airavata.agent.KernelRestartResponse
	24, // 9: org.apache.airavata.agent.AgentMessage.tunnelCreationResponse:type_name -> org.apache.airavata.agent.TunnelCreationResponse
	26, // 10: org.apache.airavata.agent.AgentMessage.tunnelTerminationResponse:type_name -> org.apache.airavata.agent.TunnelTerminationResponse
	11, // 11: org.apache.airavata.agent.AgentMessage.asyncCommandExecutionResponse:type_name -> org.apache.airavata.agent.AsyncCommandExecutionResponse
	14, // 12: org.apache.airavata.agent.AgentMessage.asyncCommandListResponse:type_name -> org.apache.airavata.agent.AsyncCommandListResponse
	16, // 13: org.apache.airavata.agent.AgentMessage.asyncCommandTerminateResponse:type_name -> org.apache.airavata.agent.AsyncCommandTerminateResponse
	1,  // 14: org.apache.airavata.agent.ServerMessage.shutdownRequest:type_name -> org.apache.airavata.agent.ShutdownRequest
	2,  // 15: org.apache.airavata.agent.ServerMessage.createAgentRequest:type_name -> org.apache.airavata.agent.CreateAgentRequest
	4,  // 16: org.apache.airavata.agent.ServerMessage.terminateAgentRequest:type_name -> org.apache.airavata.agent.TerminateAgentRequest
	6,  // 17: org.apache.airavata.agent.ServerMessage.envSetupRequest:type_name -> org.apache.airavata.agent.EnvSetupRequest
	8,  // 18: org.apache.airavata.agent.ServerMessage.commandExecutionRequest:type_name -> org.apache.airavata.agent.CommandExecutionRequest
	17, // 19: org.apache.airavata.agent.ServerMessage.pythonExecutionRequest:type_name -> org.apache.airavata.agent.PythonExecutionRequest
	19, // 20: org.apache.airavata.agent.ServerMessage.jupyterExecutionRequest:type_name -> org.apache.airavata.agent.JupyterExecutionRequest
	21, // 21: org.apache.airavata.agent.ServerMessage.kernelRestartRequest:type_name -> org.apache.airavata.agent.KernelRestartRequest
	23, // 22: org.apache.airavata.agent.ServerMessage.tunnelCreationRequest:type_name -> org.apache.airavata.agent.TunnelCreationRequest
	25, // 23: org.apache.airavata.agent.ServerMessage.tunnelTerminationRequest:type_name -> org.apache.airavata.agent.TunnelTerminationRequest
	10, // 24: org.apache.airavata.agent.ServerMessage.asyncCommandExecutionRequest:type_name -> org.apache.airavata.agent.AsyncCommandExecutionRequest
	12, // 25: org.apache.airavata.agent.ServerMessage.asyncCommandListRequest:type_name -> org.apache.airavata.agent.AsyncCommandListRequest
	15, // 26: org.apache.airavata.agent.ServerMessage.asyncCommandTerminateRequest:type_name -> org.apache.airavata.agent.AsyncCommandTerminateRequest
	27, // 27: org.apache.airavata.agent.AgentCommunicationService.createMessageBus:input_type -> org.apache.airavata.agent.AgentMessage
	28, // 28: org.apache.airavata.agent.AgentCommunicationService.createMessageBus:output_type -> org.apache.airavata.agent.ServerMessage
	28, // [28:29] is the sub-list for method output_type
	27, // [27:28] is the sub-list for method input_type
	27, // [27:27] is the sub-list for extension type_name
	27, // [27:27] is the sub-list for extension extendee
	0,  // [0:27] is the sub-list for field type_name
}

func init() { file_agent_communication_proto_init() }
func file_agent_communication_proto_init() {
	if File_agent_communication_proto != nil {
		return
	}
	file_agent_communication_proto_msgTypes[27].OneofWrappers = []any{
		(*AgentMessage_AgentPing)(nil),
		(*AgentMessage_CreateAgentResponse)(nil),
		(*AgentMessage_TerminateAgentResponse)(nil),
		(*AgentMessage_EnvSetupResponse)(nil),
		(*AgentMessage_CommandExecutionResponse)(nil),
		(*AgentMessage_PythonExecutionResponse)(nil),
		(*AgentMessage_JupyterExecutionResponse)(nil),
		(*AgentMessage_KernelRestartResponse)(nil),
		(*AgentMessage_TunnelCreationResponse)(nil),
		(*AgentMessage_TunnelTerminationResponse)(nil),
		(*AgentMessage_AsyncCommandExecutionResponse)(nil),
		(*AgentMessage_AsyncCommandListResponse)(nil),
		(*AgentMessage_AsyncCommandTerminateResponse)(nil),
	}
	file_agent_communication_proto_msgTypes[28].OneofWrappers = []any{
		(*ServerMessage_ShutdownRequest)(nil),
		(*ServerMessage_CreateAgentRequest)(nil),
		(*ServerMessage_TerminateAgentRequest)(nil),
		(*ServerMessage_EnvSetupRequest)(nil),
		(*ServerMessage_CommandExecutionRequest)(nil),
		(*ServerMessage_PythonExecutionRequest)(nil),
		(*ServerMessage_JupyterExecutionRequest)(nil),
		(*ServerMessage_KernelRestartRequest)(nil),
		(*ServerMessage_TunnelCreationRequest)(nil),
		(*ServerMessage_TunnelTerminationRequest)(nil),
		(*ServerMessage_AsyncCommandExecutionRequest)(nil),
		(*ServerMessage_AsyncCommandListRequest)(nil),
		(*ServerMessage_AsyncCommandTerminateRequest)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agent_communication_proto_rawDesc), len(file_agent_communication_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   29,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_agent_communication_proto_goTypes,
		DependencyIndexes: file_agent_communication_proto_depIdxs,
		MessageInfos:      file_agent_communication_proto_msgTypes,
	}.Build()
	File_agent_communication_proto = out.File
	file_agent_communication_proto_goTypes = nil
	file_agent_communication_proto_depIdxs = nil
}
