// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v3.21.12
// source: sglang_scheduler.proto

package proto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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)
)

// Sampling parameters matching SGLang's SamplingParams
//
// IMPORTANT: Do not use SamplingParams::default() directly!
// The proto3 defaults (0 for numeric fields) do NOT match the semantic defaults
// (temperature=1.0, top_p=1.0, top_k=-1, etc.). Always construct with explicit values
// or use the conversion functions in sglang_scheduler.rs / grpc_server.py.
type SamplingParams struct {
	state                      protoimpl.MessageState `protogen:"open.v1"`
	Temperature                float32                `protobuf:"fixed32,1,opt,name=temperature,proto3" json:"temperature,omitempty"`
	TopP                       float32                `protobuf:"fixed32,2,opt,name=top_p,json=topP,proto3" json:"top_p,omitempty"`
	TopK                       int32                  `protobuf:"varint,3,opt,name=top_k,json=topK,proto3" json:"top_k,omitempty"`
	MinP                       float32                `protobuf:"fixed32,4,opt,name=min_p,json=minP,proto3" json:"min_p,omitempty"`
	FrequencyPenalty           float32                `protobuf:"fixed32,5,opt,name=frequency_penalty,json=frequencyPenalty,proto3" json:"frequency_penalty,omitempty"`
	PresencePenalty            float32                `protobuf:"fixed32,6,opt,name=presence_penalty,json=presencePenalty,proto3" json:"presence_penalty,omitempty"`
	RepetitionPenalty          float32                `protobuf:"fixed32,7,opt,name=repetition_penalty,json=repetitionPenalty,proto3" json:"repetition_penalty,omitempty"`
	MaxNewTokens               *int32                 `protobuf:"varint,8,opt,name=max_new_tokens,json=maxNewTokens,proto3,oneof" json:"max_new_tokens,omitempty"`
	Stop                       []string               `protobuf:"bytes,9,rep,name=stop,proto3" json:"stop,omitempty"`
	StopTokenIds               []uint32               `protobuf:"varint,10,rep,packed,name=stop_token_ids,json=stopTokenIds,proto3" json:"stop_token_ids,omitempty"`
	SkipSpecialTokens          bool                   `protobuf:"varint,11,opt,name=skip_special_tokens,json=skipSpecialTokens,proto3" json:"skip_special_tokens,omitempty"`
	SpacesBetweenSpecialTokens bool                   `protobuf:"varint,12,opt,name=spaces_between_special_tokens,json=spacesBetweenSpecialTokens,proto3" json:"spaces_between_special_tokens,omitempty"`
	// Structured generation
	//
	// Types that are valid to be assigned to Constraint:
	//
	//	*SamplingParams_Regex
	//	*SamplingParams_JsonSchema
	//	*SamplingParams_EbnfGrammar
	//	*SamplingParams_StructuralTag
	Constraint isSamplingParams_Constraint `protobuf_oneof:"constraint"`
	// Speculative decoding
	N int32 `protobuf:"varint,17,opt,name=n,proto3" json:"n,omitempty"` // Number of samples
	// Additional parameters
	MinNewTokens   int32              `protobuf:"varint,18,opt,name=min_new_tokens,json=minNewTokens,proto3" json:"min_new_tokens,omitempty"`
	IgnoreEos      bool               `protobuf:"varint,19,opt,name=ignore_eos,json=ignoreEos,proto3" json:"ignore_eos,omitempty"`
	NoStopTrim     bool               `protobuf:"varint,20,opt,name=no_stop_trim,json=noStopTrim,proto3" json:"no_stop_trim,omitempty"`
	StreamInterval *int32             `protobuf:"varint,21,opt,name=stream_interval,json=streamInterval,proto3,oneof" json:"stream_interval,omitempty"`
	LogitBias      map[string]float32 `protobuf:"bytes,22,rep,name=logit_bias,json=logitBias,proto3" json:"logit_bias,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	// Custom parameters for extensibility
	CustomParams  *structpb.Struct `protobuf:"bytes,23,opt,name=custom_params,json=customParams,proto3" json:"custom_params,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SamplingParams) ProtoMessage() {}

func (x *SamplingParams) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 SamplingParams.ProtoReflect.Descriptor instead.
func (*SamplingParams) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{0}
}

func (x *SamplingParams) GetTemperature() float32 {
	if x != nil {
		return x.Temperature
	}
	return 0
}

func (x *SamplingParams) GetTopP() float32 {
	if x != nil {
		return x.TopP
	}
	return 0
}

func (x *SamplingParams) GetTopK() int32 {
	if x != nil {
		return x.TopK
	}
	return 0
}

func (x *SamplingParams) GetMinP() float32 {
	if x != nil {
		return x.MinP
	}
	return 0
}

func (x *SamplingParams) GetFrequencyPenalty() float32 {
	if x != nil {
		return x.FrequencyPenalty
	}
	return 0
}

func (x *SamplingParams) GetPresencePenalty() float32 {
	if x != nil {
		return x.PresencePenalty
	}
	return 0
}

func (x *SamplingParams) GetRepetitionPenalty() float32 {
	if x != nil {
		return x.RepetitionPenalty
	}
	return 0
}

func (x *SamplingParams) GetMaxNewTokens() int32 {
	if x != nil && x.MaxNewTokens != nil {
		return *x.MaxNewTokens
	}
	return 0
}

func (x *SamplingParams) GetStop() []string {
	if x != nil {
		return x.Stop
	}
	return nil
}

func (x *SamplingParams) GetStopTokenIds() []uint32 {
	if x != nil {
		return x.StopTokenIds
	}
	return nil
}

func (x *SamplingParams) GetSkipSpecialTokens() bool {
	if x != nil {
		return x.SkipSpecialTokens
	}
	return false
}

func (x *SamplingParams) GetSpacesBetweenSpecialTokens() bool {
	if x != nil {
		return x.SpacesBetweenSpecialTokens
	}
	return false
}

func (x *SamplingParams) GetConstraint() isSamplingParams_Constraint {
	if x != nil {
		return x.Constraint
	}
	return nil
}

func (x *SamplingParams) GetRegex() string {
	if x != nil {
		if x, ok := x.Constraint.(*SamplingParams_Regex); ok {
			return x.Regex
		}
	}
	return ""
}

func (x *SamplingParams) GetJsonSchema() string {
	if x != nil {
		if x, ok := x.Constraint.(*SamplingParams_JsonSchema); ok {
			return x.JsonSchema
		}
	}
	return ""
}

func (x *SamplingParams) GetEbnfGrammar() string {
	if x != nil {
		if x, ok := x.Constraint.(*SamplingParams_EbnfGrammar); ok {
			return x.EbnfGrammar
		}
	}
	return ""
}

func (x *SamplingParams) GetStructuralTag() string {
	if x != nil {
		if x, ok := x.Constraint.(*SamplingParams_StructuralTag); ok {
			return x.StructuralTag
		}
	}
	return ""
}

func (x *SamplingParams) GetN() int32 {
	if x != nil {
		return x.N
	}
	return 0
}

func (x *SamplingParams) GetMinNewTokens() int32 {
	if x != nil {
		return x.MinNewTokens
	}
	return 0
}

func (x *SamplingParams) GetIgnoreEos() bool {
	if x != nil {
		return x.IgnoreEos
	}
	return false
}

func (x *SamplingParams) GetNoStopTrim() bool {
	if x != nil {
		return x.NoStopTrim
	}
	return false
}

func (x *SamplingParams) GetStreamInterval() int32 {
	if x != nil && x.StreamInterval != nil {
		return *x.StreamInterval
	}
	return 0
}

func (x *SamplingParams) GetLogitBias() map[string]float32 {
	if x != nil {
		return x.LogitBias
	}
	return nil
}

func (x *SamplingParams) GetCustomParams() *structpb.Struct {
	if x != nil {
		return x.CustomParams
	}
	return nil
}

type isSamplingParams_Constraint interface {
	isSamplingParams_Constraint()
}

type SamplingParams_Regex struct {
	Regex string `protobuf:"bytes,13,opt,name=regex,proto3,oneof"`
}

type SamplingParams_JsonSchema struct {
	JsonSchema string `protobuf:"bytes,14,opt,name=json_schema,json=jsonSchema,proto3,oneof"`
}

type SamplingParams_EbnfGrammar struct {
	EbnfGrammar string `protobuf:"bytes,15,opt,name=ebnf_grammar,json=ebnfGrammar,proto3,oneof"`
}

type SamplingParams_StructuralTag struct {
	StructuralTag string `protobuf:"bytes,16,opt,name=structural_tag,json=structuralTag,proto3,oneof"`
}

func (*SamplingParams_Regex) isSamplingParams_Constraint() {}

func (*SamplingParams_JsonSchema) isSamplingParams_Constraint() {}

func (*SamplingParams_EbnfGrammar) isSamplingParams_Constraint() {}

func (*SamplingParams_StructuralTag) isSamplingParams_Constraint() {}

// Disaggregated serving parameters
type DisaggregatedParams struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	BootstrapHost string                 `protobuf:"bytes,1,opt,name=bootstrap_host,json=bootstrapHost,proto3" json:"bootstrap_host,omitempty"`
	BootstrapPort int32                  `protobuf:"varint,2,opt,name=bootstrap_port,json=bootstrapPort,proto3" json:"bootstrap_port,omitempty"`
	BootstrapRoom int32                  `protobuf:"varint,3,opt,name=bootstrap_room,json=bootstrapRoom,proto3" json:"bootstrap_room,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DisaggregatedParams) ProtoMessage() {}

func (x *DisaggregatedParams) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 DisaggregatedParams.ProtoReflect.Descriptor instead.
func (*DisaggregatedParams) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{1}
}

func (x *DisaggregatedParams) GetBootstrapHost() string {
	if x != nil {
		return x.BootstrapHost
	}
	return ""
}

func (x *DisaggregatedParams) GetBootstrapPort() int32 {
	if x != nil {
		return x.BootstrapPort
	}
	return 0
}

func (x *DisaggregatedParams) GetBootstrapRoom() int32 {
	if x != nil {
		return x.BootstrapRoom
	}
	return 0
}

type GenerateRequest struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	RequestId string                 `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Input must be tokenized (no raw text)
	Tokenized *TokenizedInput `protobuf:"bytes,2,opt,name=tokenized,proto3" json:"tokenized,omitempty"`
	// Multimodal inputs
	MmInputs *MultimodalInputs `protobuf:"bytes,3,opt,name=mm_inputs,json=mmInputs,proto3" json:"mm_inputs,omitempty"`
	// Generation parameters
	SamplingParams *SamplingParams `protobuf:"bytes,4,opt,name=sampling_params,json=samplingParams,proto3" json:"sampling_params,omitempty"`
	// Return options
	ReturnLogprob      bool     `protobuf:"varint,5,opt,name=return_logprob,json=returnLogprob,proto3" json:"return_logprob,omitempty"`
	LogprobStartLen    int32    `protobuf:"varint,6,opt,name=logprob_start_len,json=logprobStartLen,proto3" json:"logprob_start_len,omitempty"`
	TopLogprobsNum     int32    `protobuf:"varint,7,opt,name=top_logprobs_num,json=topLogprobsNum,proto3" json:"top_logprobs_num,omitempty"`
	TokenIdsLogprob    []uint32 `protobuf:"varint,8,rep,packed,name=token_ids_logprob,json=tokenIdsLogprob,proto3" json:"token_ids_logprob,omitempty"`
	ReturnHiddenStates bool     `protobuf:"varint,9,opt,name=return_hidden_states,json=returnHiddenStates,proto3" json:"return_hidden_states,omitempty"`
	// For disaggregated serving
	DisaggregatedParams *DisaggregatedParams `protobuf:"bytes,10,opt,name=disaggregated_params,json=disaggregatedParams,proto3" json:"disaggregated_params,omitempty"`
	// Custom logit processor (serialized)
	CustomLogitProcessor string `protobuf:"bytes,11,opt,name=custom_logit_processor,json=customLogitProcessor,proto3" json:"custom_logit_processor,omitempty"`
	// Request metadata
	Timestamp  *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	LogMetrics bool                   `protobuf:"varint,13,opt,name=log_metrics,json=logMetrics,proto3" json:"log_metrics,omitempty"`
	// Input embeddings (alternative to text/tokens)
	InputEmbeds []float32 `protobuf:"fixed32,14,rep,packed,name=input_embeds,json=inputEmbeds,proto3" json:"input_embeds,omitempty"`
	// LoRA adapter ID (if pre-loaded)
	LoraId string `protobuf:"bytes,15,opt,name=lora_id,json=loraId,proto3" json:"lora_id,omitempty"`
	// Data parallel routing
	DataParallelRank int32 `protobuf:"varint,16,opt,name=data_parallel_rank,json=dataParallelRank,proto3" json:"data_parallel_rank,omitempty"`
	// Whether client wants streaming response
	Stream        bool `protobuf:"varint,17,opt,name=stream,proto3" json:"stream,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GenerateRequest) ProtoMessage() {}

func (x *GenerateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 GenerateRequest.ProtoReflect.Descriptor instead.
func (*GenerateRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{2}
}

func (x *GenerateRequest) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *GenerateRequest) GetTokenized() *TokenizedInput {
	if x != nil {
		return x.Tokenized
	}
	return nil
}

func (x *GenerateRequest) GetMmInputs() *MultimodalInputs {
	if x != nil {
		return x.MmInputs
	}
	return nil
}

func (x *GenerateRequest) GetSamplingParams() *SamplingParams {
	if x != nil {
		return x.SamplingParams
	}
	return nil
}

func (x *GenerateRequest) GetReturnLogprob() bool {
	if x != nil {
		return x.ReturnLogprob
	}
	return false
}

func (x *GenerateRequest) GetLogprobStartLen() int32 {
	if x != nil {
		return x.LogprobStartLen
	}
	return 0
}

func (x *GenerateRequest) GetTopLogprobsNum() int32 {
	if x != nil {
		return x.TopLogprobsNum
	}
	return 0
}

func (x *GenerateRequest) GetTokenIdsLogprob() []uint32 {
	if x != nil {
		return x.TokenIdsLogprob
	}
	return nil
}

func (x *GenerateRequest) GetReturnHiddenStates() bool {
	if x != nil {
		return x.ReturnHiddenStates
	}
	return false
}

func (x *GenerateRequest) GetDisaggregatedParams() *DisaggregatedParams {
	if x != nil {
		return x.DisaggregatedParams
	}
	return nil
}

func (x *GenerateRequest) GetCustomLogitProcessor() string {
	if x != nil {
		return x.CustomLogitProcessor
	}
	return ""
}

func (x *GenerateRequest) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *GenerateRequest) GetLogMetrics() bool {
	if x != nil {
		return x.LogMetrics
	}
	return false
}

func (x *GenerateRequest) GetInputEmbeds() []float32 {
	if x != nil {
		return x.InputEmbeds
	}
	return nil
}

func (x *GenerateRequest) GetLoraId() string {
	if x != nil {
		return x.LoraId
	}
	return ""
}

func (x *GenerateRequest) GetDataParallelRank() int32 {
	if x != nil {
		return x.DataParallelRank
	}
	return 0
}

func (x *GenerateRequest) GetStream() bool {
	if x != nil {
		return x.Stream
	}
	return false
}

type TokenizedInput struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	OriginalText  string                 `protobuf:"bytes,1,opt,name=original_text,json=originalText,proto3" json:"original_text,omitempty"` // For reference
	InputIds      []uint32               `protobuf:"varint,2,rep,packed,name=input_ids,json=inputIds,proto3" json:"input_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TokenizedInput) ProtoMessage() {}

func (x *TokenizedInput) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 TokenizedInput.ProtoReflect.Descriptor instead.
func (*TokenizedInput) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{3}
}

func (x *TokenizedInput) GetOriginalText() string {
	if x != nil {
		return x.OriginalText
	}
	return ""
}

func (x *TokenizedInput) GetInputIds() []uint32 {
	if x != nil {
		return x.InputIds
	}
	return nil
}

type MultimodalInputs struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Simplified multimodal handling - actual data processed by tokenizer
	ImageUrls []string `protobuf:"bytes,1,rep,name=image_urls,json=imageUrls,proto3" json:"image_urls,omitempty"`
	VideoUrls []string `protobuf:"bytes,2,rep,name=video_urls,json=videoUrls,proto3" json:"video_urls,omitempty"`
	AudioUrls []string `protobuf:"bytes,3,rep,name=audio_urls,json=audioUrls,proto3" json:"audio_urls,omitempty"`
	// Pre-processed multimodal features (if available)
	ProcessedFeatures *structpb.Struct `protobuf:"bytes,4,opt,name=processed_features,json=processedFeatures,proto3" json:"processed_features,omitempty"`
	// Raw data for direct processing
	ImageData [][]byte `protobuf:"bytes,5,rep,name=image_data,json=imageData,proto3" json:"image_data,omitempty"`
	VideoData [][]byte `protobuf:"bytes,6,rep,name=video_data,json=videoData,proto3" json:"video_data,omitempty"`
	AudioData [][]byte `protobuf:"bytes,7,rep,name=audio_data,json=audioData,proto3" json:"audio_data,omitempty"`
	// Modality metadata
	Modalities    []string `protobuf:"bytes,8,rep,name=modalities,proto3" json:"modalities,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MultimodalInputs) ProtoMessage() {}

func (x *MultimodalInputs) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 MultimodalInputs.ProtoReflect.Descriptor instead.
func (*MultimodalInputs) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{4}
}

func (x *MultimodalInputs) GetImageUrls() []string {
	if x != nil {
		return x.ImageUrls
	}
	return nil
}

func (x *MultimodalInputs) GetVideoUrls() []string {
	if x != nil {
		return x.VideoUrls
	}
	return nil
}

func (x *MultimodalInputs) GetAudioUrls() []string {
	if x != nil {
		return x.AudioUrls
	}
	return nil
}

func (x *MultimodalInputs) GetProcessedFeatures() *structpb.Struct {
	if x != nil {
		return x.ProcessedFeatures
	}
	return nil
}

func (x *MultimodalInputs) GetImageData() [][]byte {
	if x != nil {
		return x.ImageData
	}
	return nil
}

func (x *MultimodalInputs) GetVideoData() [][]byte {
	if x != nil {
		return x.VideoData
	}
	return nil
}

func (x *MultimodalInputs) GetAudioData() [][]byte {
	if x != nil {
		return x.AudioData
	}
	return nil
}

func (x *MultimodalInputs) GetModalities() []string {
	if x != nil {
		return x.Modalities
	}
	return nil
}

type GenerateResponse struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	RequestId string                 `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Response type
	//
	// Types that are valid to be assigned to Response:
	//
	//	*GenerateResponse_Chunk
	//	*GenerateResponse_Complete
	//	*GenerateResponse_Error
	Response      isGenerateResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GenerateResponse) ProtoMessage() {}

func (x *GenerateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 GenerateResponse.ProtoReflect.Descriptor instead.
func (*GenerateResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{5}
}

func (x *GenerateResponse) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *GenerateResponse) GetResponse() isGenerateResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *GenerateResponse) GetChunk() *GenerateStreamChunk {
	if x != nil {
		if x, ok := x.Response.(*GenerateResponse_Chunk); ok {
			return x.Chunk
		}
	}
	return nil
}

func (x *GenerateResponse) GetComplete() *GenerateComplete {
	if x != nil {
		if x, ok := x.Response.(*GenerateResponse_Complete); ok {
			return x.Complete
		}
	}
	return nil
}

func (x *GenerateResponse) GetError() *GenerateError {
	if x != nil {
		if x, ok := x.Response.(*GenerateResponse_Error); ok {
			return x.Error
		}
	}
	return nil
}

type isGenerateResponse_Response interface {
	isGenerateResponse_Response()
}

type GenerateResponse_Chunk struct {
	Chunk *GenerateStreamChunk `protobuf:"bytes,2,opt,name=chunk,proto3,oneof"`
}

type GenerateResponse_Complete struct {
	Complete *GenerateComplete `protobuf:"bytes,3,opt,name=complete,proto3,oneof"`
}

type GenerateResponse_Error struct {
	Error *GenerateError `protobuf:"bytes,4,opt,name=error,proto3,oneof"`
}

func (*GenerateResponse_Chunk) isGenerateResponse_Response() {}

func (*GenerateResponse_Complete) isGenerateResponse_Response() {}

func (*GenerateResponse_Error) isGenerateResponse_Response() {}

type GenerateStreamChunk struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Generated tokens (incremental chunk)
	TokenIds []uint32 `protobuf:"varint,1,rep,packed,name=token_ids,json=tokenIds,proto3" json:"token_ids,omitempty"`
	// Cumulative counts
	PromptTokens     int32 `protobuf:"varint,2,opt,name=prompt_tokens,json=promptTokens,proto3" json:"prompt_tokens,omitempty"`
	CompletionTokens int32 `protobuf:"varint,3,opt,name=completion_tokens,json=completionTokens,proto3" json:"completion_tokens,omitempty"`
	CachedTokens     int32 `protobuf:"varint,4,opt,name=cached_tokens,json=cachedTokens,proto3" json:"cached_tokens,omitempty"`
	// Output logprobs (if requested) - incremental for streaming
	OutputLogprobs *OutputLogProbs `protobuf:"bytes,5,opt,name=output_logprobs,json=outputLogprobs,proto3" json:"output_logprobs,omitempty"`
	// Hidden states (if requested)
	HiddenStates []float32 `protobuf:"fixed32,6,rep,packed,name=hidden_states,json=hiddenStates,proto3" json:"hidden_states,omitempty"`
	// Input logprobs (if requested) - only in first chunk
	InputLogprobs *InputLogProbs `protobuf:"bytes,7,opt,name=input_logprobs,json=inputLogprobs,proto3" json:"input_logprobs,omitempty"`
	// Index for ordering when n>1 (for parallel request multiplexing)
	Index         uint32 `protobuf:"varint,8,opt,name=index,proto3" json:"index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GenerateStreamChunk) ProtoMessage() {}

func (x *GenerateStreamChunk) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 GenerateStreamChunk.ProtoReflect.Descriptor instead.
func (*GenerateStreamChunk) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{6}
}

func (x *GenerateStreamChunk) GetTokenIds() []uint32 {
	if x != nil {
		return x.TokenIds
	}
	return nil
}

func (x *GenerateStreamChunk) GetPromptTokens() int32 {
	if x != nil {
		return x.PromptTokens
	}
	return 0
}

func (x *GenerateStreamChunk) GetCompletionTokens() int32 {
	if x != nil {
		return x.CompletionTokens
	}
	return 0
}

func (x *GenerateStreamChunk) GetCachedTokens() int32 {
	if x != nil {
		return x.CachedTokens
	}
	return 0
}

func (x *GenerateStreamChunk) GetOutputLogprobs() *OutputLogProbs {
	if x != nil {
		return x.OutputLogprobs
	}
	return nil
}

func (x *GenerateStreamChunk) GetHiddenStates() []float32 {
	if x != nil {
		return x.HiddenStates
	}
	return nil
}

func (x *GenerateStreamChunk) GetInputLogprobs() *InputLogProbs {
	if x != nil {
		return x.InputLogprobs
	}
	return nil
}

func (x *GenerateStreamChunk) GetIndex() uint32 {
	if x != nil {
		return x.Index
	}
	return 0
}

type GenerateComplete struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Final output
	OutputIds []uint32 `protobuf:"varint,1,rep,packed,name=output_ids,json=outputIds,proto3" json:"output_ids,omitempty"`
	// Finish reason as OpenAI-compatible string ("stop", "length", "abort")
	FinishReason string `protobuf:"bytes,2,opt,name=finish_reason,json=finishReason,proto3" json:"finish_reason,omitempty"`
	// Token usage counts
	PromptTokens     int32 `protobuf:"varint,3,opt,name=prompt_tokens,json=promptTokens,proto3" json:"prompt_tokens,omitempty"`
	CompletionTokens int32 `protobuf:"varint,4,opt,name=completion_tokens,json=completionTokens,proto3" json:"completion_tokens,omitempty"`
	CachedTokens     int32 `protobuf:"varint,5,opt,name=cached_tokens,json=cachedTokens,proto3" json:"cached_tokens,omitempty"`
	// Output logprobs if requested (cumulative)
	OutputLogprobs *OutputLogProbs `protobuf:"bytes,6,opt,name=output_logprobs,json=outputLogprobs,proto3" json:"output_logprobs,omitempty"`
	// All hidden states if requested
	AllHiddenStates []*HiddenStates `protobuf:"bytes,7,rep,name=all_hidden_states,json=allHiddenStates,proto3" json:"all_hidden_states,omitempty"`
	// Matched stop information (for stop sequences)
	//
	// Types that are valid to be assigned to MatchedStop:
	//
	//	*GenerateComplete_MatchedTokenId
	//	*GenerateComplete_MatchedStopStr
	MatchedStop isGenerateComplete_MatchedStop `protobuf_oneof:"matched_stop"`
	// Input logprobs if requested (for prompt tokens)
	InputLogprobs *InputLogProbs `protobuf:"bytes,10,opt,name=input_logprobs,json=inputLogprobs,proto3" json:"input_logprobs,omitempty"`
	// Index for ordering when n>1 (for parallel request multiplexing)
	Index         uint32 `protobuf:"varint,11,opt,name=index,proto3" json:"index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GenerateComplete) ProtoMessage() {}

func (x *GenerateComplete) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 GenerateComplete.ProtoReflect.Descriptor instead.
func (*GenerateComplete) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{7}
}

func (x *GenerateComplete) GetOutputIds() []uint32 {
	if x != nil {
		return x.OutputIds
	}
	return nil
}

func (x *GenerateComplete) GetFinishReason() string {
	if x != nil {
		return x.FinishReason
	}
	return ""
}

func (x *GenerateComplete) GetPromptTokens() int32 {
	if x != nil {
		return x.PromptTokens
	}
	return 0
}

func (x *GenerateComplete) GetCompletionTokens() int32 {
	if x != nil {
		return x.CompletionTokens
	}
	return 0
}

func (x *GenerateComplete) GetCachedTokens() int32 {
	if x != nil {
		return x.CachedTokens
	}
	return 0
}

func (x *GenerateComplete) GetOutputLogprobs() *OutputLogProbs {
	if x != nil {
		return x.OutputLogprobs
	}
	return nil
}

func (x *GenerateComplete) GetAllHiddenStates() []*HiddenStates {
	if x != nil {
		return x.AllHiddenStates
	}
	return nil
}

func (x *GenerateComplete) GetMatchedStop() isGenerateComplete_MatchedStop {
	if x != nil {
		return x.MatchedStop
	}
	return nil
}

func (x *GenerateComplete) GetMatchedTokenId() uint32 {
	if x != nil {
		if x, ok := x.MatchedStop.(*GenerateComplete_MatchedTokenId); ok {
			return x.MatchedTokenId
		}
	}
	return 0
}

func (x *GenerateComplete) GetMatchedStopStr() string {
	if x != nil {
		if x, ok := x.MatchedStop.(*GenerateComplete_MatchedStopStr); ok {
			return x.MatchedStopStr
		}
	}
	return ""
}

func (x *GenerateComplete) GetInputLogprobs() *InputLogProbs {
	if x != nil {
		return x.InputLogprobs
	}
	return nil
}

func (x *GenerateComplete) GetIndex() uint32 {
	if x != nil {
		return x.Index
	}
	return 0
}

type isGenerateComplete_MatchedStop interface {
	isGenerateComplete_MatchedStop()
}

type GenerateComplete_MatchedTokenId struct {
	MatchedTokenId uint32 `protobuf:"varint,8,opt,name=matched_token_id,json=matchedTokenId,proto3,oneof"`
}

type GenerateComplete_MatchedStopStr struct {
	MatchedStopStr string `protobuf:"bytes,9,opt,name=matched_stop_str,json=matchedStopStr,proto3,oneof"`
}

func (*GenerateComplete_MatchedTokenId) isGenerateComplete_MatchedStop() {}

func (*GenerateComplete_MatchedStopStr) isGenerateComplete_MatchedStop() {}

type GenerateError struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Message        string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	HttpStatusCode string                 `protobuf:"bytes,2,opt,name=http_status_code,json=httpStatusCode,proto3" json:"http_status_code,omitempty"`
	Details        string                 `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*GenerateError) ProtoMessage() {}

func (x *GenerateError) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 GenerateError.ProtoReflect.Descriptor instead.
func (*GenerateError) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{8}
}

func (x *GenerateError) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *GenerateError) GetHttpStatusCode() string {
	if x != nil {
		return x.HttpStatusCode
	}
	return ""
}

func (x *GenerateError) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}

// Output logprobs - all values are present (no None)
type OutputLogProbs struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TokenLogprobs []float32              `protobuf:"fixed32,1,rep,packed,name=token_logprobs,json=tokenLogprobs,proto3" json:"token_logprobs,omitempty"`
	TokenIds      []int32                `protobuf:"varint,2,rep,packed,name=token_ids,json=tokenIds,proto3" json:"token_ids,omitempty"`
	// Top logprobs at each position
	TopLogprobs   []*TopLogProbs `protobuf:"bytes,3,rep,name=top_logprobs,json=topLogprobs,proto3" json:"top_logprobs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*OutputLogProbs) ProtoMessage() {}

func (x *OutputLogProbs) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 OutputLogProbs.ProtoReflect.Descriptor instead.
func (*OutputLogProbs) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{9}
}

func (x *OutputLogProbs) GetTokenLogprobs() []float32 {
	if x != nil {
		return x.TokenLogprobs
	}
	return nil
}

func (x *OutputLogProbs) GetTokenIds() []int32 {
	if x != nil {
		return x.TokenIds
	}
	return nil
}

func (x *OutputLogProbs) GetTopLogprobs() []*TopLogProbs {
	if x != nil {
		return x.TopLogprobs
	}
	return nil
}

// Input logprobs - first token has no logprob (None)
type InputLogProbs struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TokenLogprobs []*InputTokenLogProb   `protobuf:"bytes,1,rep,name=token_logprobs,json=tokenLogprobs,proto3" json:"token_logprobs,omitempty"`
	TokenIds      []int32                `protobuf:"varint,2,rep,packed,name=token_ids,json=tokenIds,proto3" json:"token_ids,omitempty"`
	// Top logprobs at each position
	TopLogprobs   []*TopLogProbs `protobuf:"bytes,3,rep,name=top_logprobs,json=topLogprobs,proto3" json:"top_logprobs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InputLogProbs) ProtoMessage() {}

func (x *InputLogProbs) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 InputLogProbs.ProtoReflect.Descriptor instead.
func (*InputLogProbs) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{10}
}

func (x *InputLogProbs) GetTokenLogprobs() []*InputTokenLogProb {
	if x != nil {
		return x.TokenLogprobs
	}
	return nil
}

func (x *InputLogProbs) GetTokenIds() []int32 {
	if x != nil {
		return x.TokenIds
	}
	return nil
}

func (x *InputLogProbs) GetTopLogprobs() []*TopLogProbs {
	if x != nil {
		return x.TopLogprobs
	}
	return nil
}

// Wrapper to represent optional logprob (first input token has no logprob)
type InputTokenLogProb struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         *float32               `protobuf:"fixed32,1,opt,name=value,proto3,oneof" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InputTokenLogProb) ProtoMessage() {}

func (x *InputTokenLogProb) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 InputTokenLogProb.ProtoReflect.Descriptor instead.
func (*InputTokenLogProb) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{11}
}

func (x *InputTokenLogProb) GetValue() float32 {
	if x != nil && x.Value != nil {
		return *x.Value
	}
	return 0
}

type TopLogProbs struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []float32              `protobuf:"fixed32,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	TokenIds      []int32                `protobuf:"varint,2,rep,packed,name=token_ids,json=tokenIds,proto3" json:"token_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TopLogProbs) ProtoMessage() {}

func (x *TopLogProbs) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 TopLogProbs.ProtoReflect.Descriptor instead.
func (*TopLogProbs) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{12}
}

func (x *TopLogProbs) GetValues() []float32 {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *TopLogProbs) GetTokenIds() []int32 {
	if x != nil {
		return x.TokenIds
	}
	return nil
}

type HiddenStates struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []float32              `protobuf:"fixed32,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	Layer         int32                  `protobuf:"varint,2,opt,name=layer,proto3" json:"layer,omitempty"`
	Position      int32                  `protobuf:"varint,3,opt,name=position,proto3" json:"position,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HiddenStates) ProtoMessage() {}

func (x *HiddenStates) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 HiddenStates.ProtoReflect.Descriptor instead.
func (*HiddenStates) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{13}
}

func (x *HiddenStates) GetValues() []float32 {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *HiddenStates) GetLayer() int32 {
	if x != nil {
		return x.Layer
	}
	return 0
}

func (x *HiddenStates) GetPosition() int32 {
	if x != nil {
		return x.Position
	}
	return 0
}

type EmbedRequest struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	RequestId string                 `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Input must be tokenized (no raw text)
	Tokenized *TokenizedInput `protobuf:"bytes,2,opt,name=tokenized,proto3" json:"tokenized,omitempty"`
	// Multimodal inputs
	MmInputs *MultimodalInputs `protobuf:"bytes,4,opt,name=mm_inputs,json=mmInputs,proto3" json:"mm_inputs,omitempty"`
	// Dummy sampling params for compatibility
	// EmbedRequest doesn't use sampling_params
	SamplingParams *SamplingParams `protobuf:"bytes,5,opt,name=sampling_params,json=samplingParams,proto3" json:"sampling_params,omitempty"`
	LogMetrics     bool            `protobuf:"varint,6,opt,name=log_metrics,json=logMetrics,proto3" json:"log_metrics,omitempty"`
	// Token type IDs for models that require them
	TokenTypeIds []int32 `protobuf:"varint,7,rep,packed,name=token_type_ids,json=tokenTypeIds,proto3" json:"token_type_ids,omitempty"`
	// Data parallel routing
	DataParallelRank int32 `protobuf:"varint,8,opt,name=data_parallel_rank,json=dataParallelRank,proto3" json:"data_parallel_rank,omitempty"`
	// For cross-encoder requests
	IsCrossEncoder bool     `protobuf:"varint,9,opt,name=is_cross_encoder,json=isCrossEncoder,proto3" json:"is_cross_encoder,omitempty"`
	Texts          []string `protobuf:"bytes,10,rep,name=texts,proto3" json:"texts,omitempty"` // For cross-encoder batch
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*EmbedRequest) ProtoMessage() {}

func (x *EmbedRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 EmbedRequest.ProtoReflect.Descriptor instead.
func (*EmbedRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{14}
}

func (x *EmbedRequest) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *EmbedRequest) GetTokenized() *TokenizedInput {
	if x != nil {
		return x.Tokenized
	}
	return nil
}

func (x *EmbedRequest) GetMmInputs() *MultimodalInputs {
	if x != nil {
		return x.MmInputs
	}
	return nil
}

func (x *EmbedRequest) GetSamplingParams() *SamplingParams {
	if x != nil {
		return x.SamplingParams
	}
	return nil
}

func (x *EmbedRequest) GetLogMetrics() bool {
	if x != nil {
		return x.LogMetrics
	}
	return false
}

func (x *EmbedRequest) GetTokenTypeIds() []int32 {
	if x != nil {
		return x.TokenTypeIds
	}
	return nil
}

func (x *EmbedRequest) GetDataParallelRank() int32 {
	if x != nil {
		return x.DataParallelRank
	}
	return 0
}

func (x *EmbedRequest) GetIsCrossEncoder() bool {
	if x != nil {
		return x.IsCrossEncoder
	}
	return false
}

func (x *EmbedRequest) GetTexts() []string {
	if x != nil {
		return x.Texts
	}
	return nil
}

type EmbedResponse struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	RequestId string                 `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Types that are valid to be assigned to Response:
	//
	//	*EmbedResponse_Complete
	//	*EmbedResponse_Error
	Response      isEmbedResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EmbedResponse) ProtoMessage() {}

func (x *EmbedResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 EmbedResponse.ProtoReflect.Descriptor instead.
func (*EmbedResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{15}
}

func (x *EmbedResponse) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *EmbedResponse) GetResponse() isEmbedResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *EmbedResponse) GetComplete() *EmbedComplete {
	if x != nil {
		if x, ok := x.Response.(*EmbedResponse_Complete); ok {
			return x.Complete
		}
	}
	return nil
}

func (x *EmbedResponse) GetError() *EmbedError {
	if x != nil {
		if x, ok := x.Response.(*EmbedResponse_Error); ok {
			return x.Error
		}
	}
	return nil
}

type isEmbedResponse_Response interface {
	isEmbedResponse_Response()
}

type EmbedResponse_Complete struct {
	Complete *EmbedComplete `protobuf:"bytes,2,opt,name=complete,proto3,oneof"`
}

type EmbedResponse_Error struct {
	Error *EmbedError `protobuf:"bytes,3,opt,name=error,proto3,oneof"`
}

func (*EmbedResponse_Complete) isEmbedResponse_Response() {}

func (*EmbedResponse_Error) isEmbedResponse_Response() {}

type EmbedComplete struct {
	state        protoimpl.MessageState `protogen:"open.v1"`
	Embedding    []float32              `protobuf:"fixed32,1,rep,packed,name=embedding,proto3" json:"embedding,omitempty"`
	PromptTokens int32                  `protobuf:"varint,2,opt,name=prompt_tokens,json=promptTokens,proto3" json:"prompt_tokens,omitempty"`
	CachedTokens int32                  `protobuf:"varint,3,opt,name=cached_tokens,json=cachedTokens,proto3" json:"cached_tokens,omitempty"`
	// Additional metadata
	EmbeddingDim int32 `protobuf:"varint,4,opt,name=embedding_dim,json=embeddingDim,proto3" json:"embedding_dim,omitempty"`
	// For batch embeddings
	BatchEmbeddings []*Embedding `protobuf:"bytes,5,rep,name=batch_embeddings,json=batchEmbeddings,proto3" json:"batch_embeddings,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*EmbedComplete) ProtoMessage() {}

func (x *EmbedComplete) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 EmbedComplete.ProtoReflect.Descriptor instead.
func (*EmbedComplete) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{16}
}

func (x *EmbedComplete) GetEmbedding() []float32 {
	if x != nil {
		return x.Embedding
	}
	return nil
}

func (x *EmbedComplete) GetPromptTokens() int32 {
	if x != nil {
		return x.PromptTokens
	}
	return 0
}

func (x *EmbedComplete) GetCachedTokens() int32 {
	if x != nil {
		return x.CachedTokens
	}
	return 0
}

func (x *EmbedComplete) GetEmbeddingDim() int32 {
	if x != nil {
		return x.EmbeddingDim
	}
	return 0
}

func (x *EmbedComplete) GetBatchEmbeddings() []*Embedding {
	if x != nil {
		return x.BatchEmbeddings
	}
	return nil
}

type Embedding struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Values        []float32              `protobuf:"fixed32,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	Index         int32                  `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Embedding) ProtoMessage() {}

func (x *Embedding) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 Embedding.ProtoReflect.Descriptor instead.
func (*Embedding) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{17}
}

func (x *Embedding) GetValues() []float32 {
	if x != nil {
		return x.Values
	}
	return nil
}

func (x *Embedding) GetIndex() int32 {
	if x != nil {
		return x.Index
	}
	return 0
}

type EmbedError struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Code          string                 `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"`
	Details       string                 `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EmbedError) ProtoMessage() {}

func (x *EmbedError) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 EmbedError.ProtoReflect.Descriptor instead.
func (*EmbedError) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{18}
}

func (x *EmbedError) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

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

func (x *EmbedError) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}

type HealthCheckRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthCheckRequest) ProtoMessage() {}

func (x *HealthCheckRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 HealthCheckRequest.ProtoReflect.Descriptor instead.
func (*HealthCheckRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{19}
}

type HealthCheckResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Healthy       bool                   `protobuf:"varint,1,opt,name=healthy,proto3" json:"healthy,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthCheckResponse) ProtoMessage() {}

func (x *HealthCheckResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 HealthCheckResponse.ProtoReflect.Descriptor instead.
func (*HealthCheckResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{20}
}

func (x *HealthCheckResponse) GetHealthy() bool {
	if x != nil {
		return x.Healthy
	}
	return false
}

func (x *HealthCheckResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

type AbortRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RequestId     string                 `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	Reason        string                 `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AbortRequest) ProtoMessage() {}

func (x *AbortRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 AbortRequest.ProtoReflect.Descriptor instead.
func (*AbortRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{21}
}

func (x *AbortRequest) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *AbortRequest) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type AbortResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AbortResponse) ProtoMessage() {}

func (x *AbortResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 AbortResponse.ProtoReflect.Descriptor instead.
func (*AbortResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{22}
}

func (x *AbortResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *AbortResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// Load LoRA adapter
type LoadLoRARequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AdapterId     string                 `protobuf:"bytes,1,opt,name=adapter_id,json=adapterId,proto3" json:"adapter_id,omitempty"`
	AdapterPath   string                 `protobuf:"bytes,2,opt,name=adapter_path,json=adapterPath,proto3" json:"adapter_path,omitempty"`
	Rank          int32                  `protobuf:"varint,3,opt,name=rank,proto3" json:"rank,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LoadLoRARequest) ProtoMessage() {}

func (x *LoadLoRARequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 LoadLoRARequest.ProtoReflect.Descriptor instead.
func (*LoadLoRARequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{23}
}

func (x *LoadLoRARequest) GetAdapterId() string {
	if x != nil {
		return x.AdapterId
	}
	return ""
}

func (x *LoadLoRARequest) GetAdapterPath() string {
	if x != nil {
		return x.AdapterPath
	}
	return ""
}

func (x *LoadLoRARequest) GetRank() int32 {
	if x != nil {
		return x.Rank
	}
	return 0
}

type LoadLoRAResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	AdapterId     string                 `protobuf:"bytes,2,opt,name=adapter_id,json=adapterId,proto3" json:"adapter_id,omitempty"`
	Message       string                 `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LoadLoRAResponse) ProtoMessage() {}

func (x *LoadLoRAResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 LoadLoRAResponse.ProtoReflect.Descriptor instead.
func (*LoadLoRAResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{24}
}

func (x *LoadLoRAResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *LoadLoRAResponse) GetAdapterId() string {
	if x != nil {
		return x.AdapterId
	}
	return ""
}

func (x *LoadLoRAResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// Unload LoRA adapter
type UnloadLoRARequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AdapterId     string                 `protobuf:"bytes,1,opt,name=adapter_id,json=adapterId,proto3" json:"adapter_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UnloadLoRARequest) ProtoMessage() {}

func (x *UnloadLoRARequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 UnloadLoRARequest.ProtoReflect.Descriptor instead.
func (*UnloadLoRARequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{25}
}

func (x *UnloadLoRARequest) GetAdapterId() string {
	if x != nil {
		return x.AdapterId
	}
	return ""
}

type UnloadLoRAResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UnloadLoRAResponse) ProtoMessage() {}

func (x *UnloadLoRAResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 UnloadLoRAResponse.ProtoReflect.Descriptor instead.
func (*UnloadLoRAResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{26}
}

func (x *UnloadLoRAResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *UnloadLoRAResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// Update weights
type UpdateWeightsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Source:
	//
	//	*UpdateWeightsRequest_DiskPath
	//	*UpdateWeightsRequest_TensorData
	//	*UpdateWeightsRequest_RemoteUrl
	Source        isUpdateWeightsRequest_Source `protobuf_oneof:"source"`
	WeightName    string                        `protobuf:"bytes,4,opt,name=weight_name,json=weightName,proto3" json:"weight_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateWeightsRequest) ProtoMessage() {}

func (x *UpdateWeightsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 UpdateWeightsRequest.ProtoReflect.Descriptor instead.
func (*UpdateWeightsRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{27}
}

func (x *UpdateWeightsRequest) GetSource() isUpdateWeightsRequest_Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *UpdateWeightsRequest) GetDiskPath() string {
	if x != nil {
		if x, ok := x.Source.(*UpdateWeightsRequest_DiskPath); ok {
			return x.DiskPath
		}
	}
	return ""
}

func (x *UpdateWeightsRequest) GetTensorData() []byte {
	if x != nil {
		if x, ok := x.Source.(*UpdateWeightsRequest_TensorData); ok {
			return x.TensorData
		}
	}
	return nil
}

func (x *UpdateWeightsRequest) GetRemoteUrl() string {
	if x != nil {
		if x, ok := x.Source.(*UpdateWeightsRequest_RemoteUrl); ok {
			return x.RemoteUrl
		}
	}
	return ""
}

func (x *UpdateWeightsRequest) GetWeightName() string {
	if x != nil {
		return x.WeightName
	}
	return ""
}

type isUpdateWeightsRequest_Source interface {
	isUpdateWeightsRequest_Source()
}

type UpdateWeightsRequest_DiskPath struct {
	DiskPath string `protobuf:"bytes,1,opt,name=disk_path,json=diskPath,proto3,oneof"`
}

type UpdateWeightsRequest_TensorData struct {
	TensorData []byte `protobuf:"bytes,2,opt,name=tensor_data,json=tensorData,proto3,oneof"`
}

type UpdateWeightsRequest_RemoteUrl struct {
	RemoteUrl string `protobuf:"bytes,3,opt,name=remote_url,json=remoteUrl,proto3,oneof"`
}

func (*UpdateWeightsRequest_DiskPath) isUpdateWeightsRequest_Source() {}

func (*UpdateWeightsRequest_TensorData) isUpdateWeightsRequest_Source() {}

func (*UpdateWeightsRequest_RemoteUrl) isUpdateWeightsRequest_Source() {}

type UpdateWeightsResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateWeightsResponse) ProtoMessage() {}

func (x *UpdateWeightsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_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 UpdateWeightsResponse.ProtoReflect.Descriptor instead.
func (*UpdateWeightsResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{28}
}

func (x *UpdateWeightsResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *UpdateWeightsResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// Get internal state for debugging
type GetInternalStateRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StateKeys     []string               `protobuf:"bytes,1,rep,name=state_keys,json=stateKeys,proto3" json:"state_keys,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetInternalStateRequest) Reset() {
	*x = GetInternalStateRequest{}
	mi := &file_sglang_scheduler_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetInternalStateRequest) ProtoMessage() {}

func (x *GetInternalStateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[29]
	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 GetInternalStateRequest.ProtoReflect.Descriptor instead.
func (*GetInternalStateRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{29}
}

func (x *GetInternalStateRequest) GetStateKeys() []string {
	if x != nil {
		return x.StateKeys
	}
	return nil
}

type GetInternalStateResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	State         *structpb.Struct       `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetInternalStateResponse) Reset() {
	*x = GetInternalStateResponse{}
	mi := &file_sglang_scheduler_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetInternalStateResponse) ProtoMessage() {}

func (x *GetInternalStateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[30]
	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 GetInternalStateResponse.ProtoReflect.Descriptor instead.
func (*GetInternalStateResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{30}
}

func (x *GetInternalStateResponse) GetState() *structpb.Struct {
	if x != nil {
		return x.State
	}
	return nil
}

// Set internal state for testing
type SetInternalStateRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	State         *structpb.Struct       `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SetInternalStateRequest) Reset() {
	*x = SetInternalStateRequest{}
	mi := &file_sglang_scheduler_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SetInternalStateRequest) ProtoMessage() {}

func (x *SetInternalStateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[31]
	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 SetInternalStateRequest.ProtoReflect.Descriptor instead.
func (*SetInternalStateRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{31}
}

func (x *SetInternalStateRequest) GetState() *structpb.Struct {
	if x != nil {
		return x.State
	}
	return nil
}

type SetInternalStateResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Success       bool                   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SetInternalStateResponse) Reset() {
	*x = SetInternalStateResponse{}
	mi := &file_sglang_scheduler_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SetInternalStateResponse) ProtoMessage() {}

func (x *SetInternalStateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[32]
	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 SetInternalStateResponse.ProtoReflect.Descriptor instead.
func (*SetInternalStateResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{32}
}

func (x *SetInternalStateResponse) GetSuccess() bool {
	if x != nil {
		return x.Success
	}
	return false
}

func (x *SetInternalStateResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// Get model information
type GetModelInfoRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetModelInfoRequest) Reset() {
	*x = GetModelInfoRequest{}
	mi := &file_sglang_scheduler_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetModelInfoRequest) ProtoMessage() {}

func (x *GetModelInfoRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[33]
	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 GetModelInfoRequest.ProtoReflect.Descriptor instead.
func (*GetModelInfoRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{33}
}

type GetModelInfoResponse struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	ModelPath               string                 `protobuf:"bytes,1,opt,name=model_path,json=modelPath,proto3" json:"model_path,omitempty"`
	TokenizerPath           string                 `protobuf:"bytes,2,opt,name=tokenizer_path,json=tokenizerPath,proto3" json:"tokenizer_path,omitempty"`
	IsGeneration            bool                   `protobuf:"varint,3,opt,name=is_generation,json=isGeneration,proto3" json:"is_generation,omitempty"`
	PreferredSamplingParams string                 `protobuf:"bytes,4,opt,name=preferred_sampling_params,json=preferredSamplingParams,proto3" json:"preferred_sampling_params,omitempty"` // JSON string or empty
	WeightVersion           string                 `protobuf:"bytes,5,opt,name=weight_version,json=weightVersion,proto3" json:"weight_version,omitempty"`
	ServedModelName         string                 `protobuf:"bytes,6,opt,name=served_model_name,json=servedModelName,proto3" json:"served_model_name,omitempty"`
	MaxContextLength        int32                  `protobuf:"varint,7,opt,name=max_context_length,json=maxContextLength,proto3" json:"max_context_length,omitempty"`
	VocabSize               int32                  `protobuf:"varint,8,opt,name=vocab_size,json=vocabSize,proto3" json:"vocab_size,omitempty"`
	SupportsVision          bool                   `protobuf:"varint,9,opt,name=supports_vision,json=supportsVision,proto3" json:"supports_vision,omitempty"`
	ModelType               string                 `protobuf:"bytes,10,opt,name=model_type,json=modelType,proto3" json:"model_type,omitempty"`
	EosTokenIds             []int32                `protobuf:"varint,11,rep,packed,name=eos_token_ids,json=eosTokenIds,proto3" json:"eos_token_ids,omitempty"`
	PadTokenId              int32                  `protobuf:"varint,12,opt,name=pad_token_id,json=padTokenId,proto3" json:"pad_token_id,omitempty"`
	BosTokenId              int32                  `protobuf:"varint,13,opt,name=bos_token_id,json=bosTokenId,proto3" json:"bos_token_id,omitempty"`
	MaxReqInputLen          int32                  `protobuf:"varint,14,opt,name=max_req_input_len,json=maxReqInputLen,proto3" json:"max_req_input_len,omitempty"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

func (x *GetModelInfoResponse) Reset() {
	*x = GetModelInfoResponse{}
	mi := &file_sglang_scheduler_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetModelInfoResponse) ProtoMessage() {}

func (x *GetModelInfoResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[34]
	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 GetModelInfoResponse.ProtoReflect.Descriptor instead.
func (*GetModelInfoResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{34}
}

func (x *GetModelInfoResponse) GetModelPath() string {
	if x != nil {
		return x.ModelPath
	}
	return ""
}

func (x *GetModelInfoResponse) GetTokenizerPath() string {
	if x != nil {
		return x.TokenizerPath
	}
	return ""
}

func (x *GetModelInfoResponse) GetIsGeneration() bool {
	if x != nil {
		return x.IsGeneration
	}
	return false
}

func (x *GetModelInfoResponse) GetPreferredSamplingParams() string {
	if x != nil {
		return x.PreferredSamplingParams
	}
	return ""
}

func (x *GetModelInfoResponse) GetWeightVersion() string {
	if x != nil {
		return x.WeightVersion
	}
	return ""
}

func (x *GetModelInfoResponse) GetServedModelName() string {
	if x != nil {
		return x.ServedModelName
	}
	return ""
}

func (x *GetModelInfoResponse) GetMaxContextLength() int32 {
	if x != nil {
		return x.MaxContextLength
	}
	return 0
}

func (x *GetModelInfoResponse) GetVocabSize() int32 {
	if x != nil {
		return x.VocabSize
	}
	return 0
}

func (x *GetModelInfoResponse) GetSupportsVision() bool {
	if x != nil {
		return x.SupportsVision
	}
	return false
}

func (x *GetModelInfoResponse) GetModelType() string {
	if x != nil {
		return x.ModelType
	}
	return ""
}

func (x *GetModelInfoResponse) GetEosTokenIds() []int32 {
	if x != nil {
		return x.EosTokenIds
	}
	return nil
}

func (x *GetModelInfoResponse) GetPadTokenId() int32 {
	if x != nil {
		return x.PadTokenId
	}
	return 0
}

func (x *GetModelInfoResponse) GetBosTokenId() int32 {
	if x != nil {
		return x.BosTokenId
	}
	return 0
}

func (x *GetModelInfoResponse) GetMaxReqInputLen() int32 {
	if x != nil {
		return x.MaxReqInputLen
	}
	return 0
}

// Get server information
type GetServerInfoRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetServerInfoRequest) Reset() {
	*x = GetServerInfoRequest{}
	mi := &file_sglang_scheduler_proto_msgTypes[35]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetServerInfoRequest) ProtoMessage() {}

func (x *GetServerInfoRequest) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[35]
	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 GetServerInfoRequest.ProtoReflect.Descriptor instead.
func (*GetServerInfoRequest) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{35}
}

type GetServerInfoResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Server configuration (as structured data)
	ServerArgs *structpb.Struct `protobuf:"bytes,1,opt,name=server_args,json=serverArgs,proto3" json:"server_args,omitempty"`
	// Scheduler metrics (from scheduler initialization)
	SchedulerInfo *structpb.Struct `protobuf:"bytes,2,opt,name=scheduler_info,json=schedulerInfo,proto3" json:"scheduler_info,omitempty"`
	// Runtime state
	ActiveRequests       int32   `protobuf:"varint,3,opt,name=active_requests,json=activeRequests,proto3" json:"active_requests,omitempty"`
	IsPaused             bool    `protobuf:"varint,4,opt,name=is_paused,json=isPaused,proto3" json:"is_paused,omitempty"`
	LastReceiveTimestamp float64 `protobuf:"fixed64,5,opt,name=last_receive_timestamp,json=lastReceiveTimestamp,proto3" json:"last_receive_timestamp,omitempty"`
	UptimeSeconds        float64 `protobuf:"fixed64,6,opt,name=uptime_seconds,json=uptimeSeconds,proto3" json:"uptime_seconds,omitempty"`
	// Version info
	SglangVersion string `protobuf:"bytes,7,opt,name=sglang_version,json=sglangVersion,proto3" json:"sglang_version,omitempty"`
	// Server metadata
	ServerType    string                 `protobuf:"bytes,8,opt,name=server_type,json=serverType,proto3" json:"server_type,omitempty"` // "grpc"
	StartTime     *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetServerInfoResponse) Reset() {
	*x = GetServerInfoResponse{}
	mi := &file_sglang_scheduler_proto_msgTypes[36]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetServerInfoResponse) ProtoMessage() {}

func (x *GetServerInfoResponse) ProtoReflect() protoreflect.Message {
	mi := &file_sglang_scheduler_proto_msgTypes[36]
	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 GetServerInfoResponse.ProtoReflect.Descriptor instead.
func (*GetServerInfoResponse) Descriptor() ([]byte, []int) {
	return file_sglang_scheduler_proto_rawDescGZIP(), []int{36}
}

func (x *GetServerInfoResponse) GetServerArgs() *structpb.Struct {
	if x != nil {
		return x.ServerArgs
	}
	return nil
}

func (x *GetServerInfoResponse) GetSchedulerInfo() *structpb.Struct {
	if x != nil {
		return x.SchedulerInfo
	}
	return nil
}

func (x *GetServerInfoResponse) GetActiveRequests() int32 {
	if x != nil {
		return x.ActiveRequests
	}
	return 0
}

func (x *GetServerInfoResponse) GetIsPaused() bool {
	if x != nil {
		return x.IsPaused
	}
	return false
}

func (x *GetServerInfoResponse) GetLastReceiveTimestamp() float64 {
	if x != nil {
		return x.LastReceiveTimestamp
	}
	return 0
}

func (x *GetServerInfoResponse) GetUptimeSeconds() float64 {
	if x != nil {
		return x.UptimeSeconds
	}
	return 0
}

func (x *GetServerInfoResponse) GetSglangVersion() string {
	if x != nil {
		return x.SglangVersion
	}
	return ""
}

func (x *GetServerInfoResponse) GetServerType() string {
	if x != nil {
		return x.ServerType
	}
	return ""
}

func (x *GetServerInfoResponse) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

var File_sglang_scheduler_proto protoreflect.FileDescriptor

const file_sglang_scheduler_proto_rawDesc = "" +
	"\n" +
	"\x16sglang_scheduler.proto\x12\x15sglang.grpc.scheduler\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x82\b\n" +
	"\x0eSamplingParams\x12 \n" +
	"\vtemperature\x18\x01 \x01(\x02R\vtemperature\x12\x13\n" +
	"\x05top_p\x18\x02 \x01(\x02R\x04topP\x12\x13\n" +
	"\x05top_k\x18\x03 \x01(\x05R\x04topK\x12\x13\n" +
	"\x05min_p\x18\x04 \x01(\x02R\x04minP\x12+\n" +
	"\x11frequency_penalty\x18\x05 \x01(\x02R\x10frequencyPenalty\x12)\n" +
	"\x10presence_penalty\x18\x06 \x01(\x02R\x0fpresencePenalty\x12-\n" +
	"\x12repetition_penalty\x18\a \x01(\x02R\x11repetitionPenalty\x12)\n" +
	"\x0emax_new_tokens\x18\b \x01(\x05H\x01R\fmaxNewTokens\x88\x01\x01\x12\x12\n" +
	"\x04stop\x18\t \x03(\tR\x04stop\x12$\n" +
	"\x0estop_token_ids\x18\n" +
	" \x03(\rR\fstopTokenIds\x12.\n" +
	"\x13skip_special_tokens\x18\v \x01(\bR\x11skipSpecialTokens\x12A\n" +
	"\x1dspaces_between_special_tokens\x18\f \x01(\bR\x1aspacesBetweenSpecialTokens\x12\x16\n" +
	"\x05regex\x18\r \x01(\tH\x00R\x05regex\x12!\n" +
	"\vjson_schema\x18\x0e \x01(\tH\x00R\n" +
	"jsonSchema\x12#\n" +
	"\febnf_grammar\x18\x0f \x01(\tH\x00R\vebnfGrammar\x12'\n" +
	"\x0estructural_tag\x18\x10 \x01(\tH\x00R\rstructuralTag\x12\f\n" +
	"\x01n\x18\x11 \x01(\x05R\x01n\x12$\n" +
	"\x0emin_new_tokens\x18\x12 \x01(\x05R\fminNewTokens\x12\x1d\n" +
	"\n" +
	"ignore_eos\x18\x13 \x01(\bR\tignoreEos\x12 \n" +
	"\fno_stop_trim\x18\x14 \x01(\bR\n" +
	"noStopTrim\x12,\n" +
	"\x0fstream_interval\x18\x15 \x01(\x05H\x02R\x0estreamInterval\x88\x01\x01\x12S\n" +
	"\n" +
	"logit_bias\x18\x16 \x03(\v24.sglang.grpc.scheduler.SamplingParams.LogitBiasEntryR\tlogitBias\x12<\n" +
	"\rcustom_params\x18\x17 \x01(\v2\x17.google.protobuf.StructR\fcustomParams\x1a<\n" +
	"\x0eLogitBiasEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x02R\x05value:\x028\x01B\f\n" +
	"\n" +
	"constraintB\x11\n" +
	"\x0f_max_new_tokensB\x12\n" +
	"\x10_stream_interval\"\x8a\x01\n" +
	"\x13DisaggregatedParams\x12%\n" +
	"\x0ebootstrap_host\x18\x01 \x01(\tR\rbootstrapHost\x12%\n" +
	"\x0ebootstrap_port\x18\x02 \x01(\x05R\rbootstrapPort\x12%\n" +
	"\x0ebootstrap_room\x18\x03 \x01(\x05R\rbootstrapRoom\"\xd8\x06\n" +
	"\x0fGenerateRequest\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12C\n" +
	"\ttokenized\x18\x02 \x01(\v2%.sglang.grpc.scheduler.TokenizedInputR\ttokenized\x12D\n" +
	"\tmm_inputs\x18\x03 \x01(\v2'.sglang.grpc.scheduler.MultimodalInputsR\bmmInputs\x12N\n" +
	"\x0fsampling_params\x18\x04 \x01(\v2%.sglang.grpc.scheduler.SamplingParamsR\x0esamplingParams\x12%\n" +
	"\x0ereturn_logprob\x18\x05 \x01(\bR\rreturnLogprob\x12*\n" +
	"\x11logprob_start_len\x18\x06 \x01(\x05R\x0flogprobStartLen\x12(\n" +
	"\x10top_logprobs_num\x18\a \x01(\x05R\x0etopLogprobsNum\x12*\n" +
	"\x11token_ids_logprob\x18\b \x03(\rR\x0ftokenIdsLogprob\x120\n" +
	"\x14return_hidden_states\x18\t \x01(\bR\x12returnHiddenStates\x12]\n" +
	"\x14disaggregated_params\x18\n" +
	" \x01(\v2*.sglang.grpc.scheduler.DisaggregatedParamsR\x13disaggregatedParams\x124\n" +
	"\x16custom_logit_processor\x18\v \x01(\tR\x14customLogitProcessor\x128\n" +
	"\ttimestamp\x18\f \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12\x1f\n" +
	"\vlog_metrics\x18\r \x01(\bR\n" +
	"logMetrics\x12!\n" +
	"\finput_embeds\x18\x0e \x03(\x02R\vinputEmbeds\x12\x17\n" +
	"\alora_id\x18\x0f \x01(\tR\x06loraId\x12,\n" +
	"\x12data_parallel_rank\x18\x10 \x01(\x05R\x10dataParallelRank\x12\x16\n" +
	"\x06stream\x18\x11 \x01(\bR\x06stream\"R\n" +
	"\x0eTokenizedInput\x12#\n" +
	"\roriginal_text\x18\x01 \x01(\tR\foriginalText\x12\x1b\n" +
	"\tinput_ids\x18\x02 \x03(\rR\binputIds\"\xb4\x02\n" +
	"\x10MultimodalInputs\x12\x1d\n" +
	"\n" +
	"image_urls\x18\x01 \x03(\tR\timageUrls\x12\x1d\n" +
	"\n" +
	"video_urls\x18\x02 \x03(\tR\tvideoUrls\x12\x1d\n" +
	"\n" +
	"audio_urls\x18\x03 \x03(\tR\taudioUrls\x12F\n" +
	"\x12processed_features\x18\x04 \x01(\v2\x17.google.protobuf.StructR\x11processedFeatures\x12\x1d\n" +
	"\n" +
	"image_data\x18\x05 \x03(\fR\timageData\x12\x1d\n" +
	"\n" +
	"video_data\x18\x06 \x03(\fR\tvideoData\x12\x1d\n" +
	"\n" +
	"audio_data\x18\a \x03(\fR\taudioData\x12\x1e\n" +
	"\n" +
	"modalities\x18\b \x03(\tR\n" +
	"modalities\"\x86\x02\n" +
	"\x10GenerateResponse\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12B\n" +
	"\x05chunk\x18\x02 \x01(\v2*.sglang.grpc.scheduler.GenerateStreamChunkH\x00R\x05chunk\x12E\n" +
	"\bcomplete\x18\x03 \x01(\v2'.sglang.grpc.scheduler.GenerateCompleteH\x00R\bcomplete\x12<\n" +
	"\x05error\x18\x04 \x01(\v2$.sglang.grpc.scheduler.GenerateErrorH\x00R\x05errorB\n" +
	"\n" +
	"\bresponse\"\x81\x03\n" +
	"\x13GenerateStreamChunk\x12\x1b\n" +
	"\ttoken_ids\x18\x01 \x03(\rR\btokenIds\x12#\n" +
	"\rprompt_tokens\x18\x02 \x01(\x05R\fpromptTokens\x12+\n" +
	"\x11completion_tokens\x18\x03 \x01(\x05R\x10completionTokens\x12#\n" +
	"\rcached_tokens\x18\x04 \x01(\x05R\fcachedTokens\x12N\n" +
	"\x0foutput_logprobs\x18\x05 \x01(\v2%.sglang.grpc.scheduler.OutputLogProbsR\x0eoutputLogprobs\x12#\n" +
	"\rhidden_states\x18\x06 \x03(\x02R\fhiddenStates\x12K\n" +
	"\x0einput_logprobs\x18\a \x01(\v2$.sglang.grpc.scheduler.InputLogProbsR\rinputLogprobs\x12\x14\n" +
	"\x05index\x18\b \x01(\rR\x05index\"\xb9\x04\n" +
	"\x10GenerateComplete\x12\x1d\n" +
	"\n" +
	"output_ids\x18\x01 \x03(\rR\toutputIds\x12#\n" +
	"\rfinish_reason\x18\x02 \x01(\tR\ffinishReason\x12#\n" +
	"\rprompt_tokens\x18\x03 \x01(\x05R\fpromptTokens\x12+\n" +
	"\x11completion_tokens\x18\x04 \x01(\x05R\x10completionTokens\x12#\n" +
	"\rcached_tokens\x18\x05 \x01(\x05R\fcachedTokens\x12N\n" +
	"\x0foutput_logprobs\x18\x06 \x01(\v2%.sglang.grpc.scheduler.OutputLogProbsR\x0eoutputLogprobs\x12O\n" +
	"\x11all_hidden_states\x18\a \x03(\v2#.sglang.grpc.scheduler.HiddenStatesR\x0fallHiddenStates\x12*\n" +
	"\x10matched_token_id\x18\b \x01(\rH\x00R\x0ematchedTokenId\x12*\n" +
	"\x10matched_stop_str\x18\t \x01(\tH\x00R\x0ematchedStopStr\x12K\n" +
	"\x0einput_logprobs\x18\n" +
	" \x01(\v2$.sglang.grpc.scheduler.InputLogProbsR\rinputLogprobs\x12\x14\n" +
	"\x05index\x18\v \x01(\rR\x05indexB\x0e\n" +
	"\fmatched_stop\"m\n" +
	"\rGenerateError\x12\x18\n" +
	"\amessage\x18\x01 \x01(\tR\amessage\x12(\n" +
	"\x10http_status_code\x18\x02 \x01(\tR\x0ehttpStatusCode\x12\x18\n" +
	"\adetails\x18\x03 \x01(\tR\adetails\"\x9b\x01\n" +
	"\x0eOutputLogProbs\x12%\n" +
	"\x0etoken_logprobs\x18\x01 \x03(\x02R\rtokenLogprobs\x12\x1b\n" +
	"\ttoken_ids\x18\x02 \x03(\x05R\btokenIds\x12E\n" +
	"\ftop_logprobs\x18\x03 \x03(\v2\".sglang.grpc.scheduler.TopLogProbsR\vtopLogprobs\"\xc4\x01\n" +
	"\rInputLogProbs\x12O\n" +
	"\x0etoken_logprobs\x18\x01 \x03(\v2(.sglang.grpc.scheduler.InputTokenLogProbR\rtokenLogprobs\x12\x1b\n" +
	"\ttoken_ids\x18\x02 \x03(\x05R\btokenIds\x12E\n" +
	"\ftop_logprobs\x18\x03 \x03(\v2\".sglang.grpc.scheduler.TopLogProbsR\vtopLogprobs\"8\n" +
	"\x11InputTokenLogProb\x12\x19\n" +
	"\x05value\x18\x01 \x01(\x02H\x00R\x05value\x88\x01\x01B\b\n" +
	"\x06_value\"B\n" +
	"\vTopLogProbs\x12\x16\n" +
	"\x06values\x18\x01 \x03(\x02R\x06values\x12\x1b\n" +
	"\ttoken_ids\x18\x02 \x03(\x05R\btokenIds\"X\n" +
	"\fHiddenStates\x12\x16\n" +
	"\x06values\x18\x01 \x03(\x02R\x06values\x12\x14\n" +
	"\x05layer\x18\x02 \x01(\x05R\x05layer\x12\x1a\n" +
	"\bposition\x18\x03 \x01(\x05R\bposition\"\xbd\x03\n" +
	"\fEmbedRequest\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12C\n" +
	"\ttokenized\x18\x02 \x01(\v2%.sglang.grpc.scheduler.TokenizedInputR\ttokenized\x12D\n" +
	"\tmm_inputs\x18\x04 \x01(\v2'.sglang.grpc.scheduler.MultimodalInputsR\bmmInputs\x12N\n" +
	"\x0fsampling_params\x18\x05 \x01(\v2%.sglang.grpc.scheduler.SamplingParamsR\x0esamplingParams\x12\x1f\n" +
	"\vlog_metrics\x18\x06 \x01(\bR\n" +
	"logMetrics\x12$\n" +
	"\x0etoken_type_ids\x18\a \x03(\x05R\ftokenTypeIds\x12,\n" +
	"\x12data_parallel_rank\x18\b \x01(\x05R\x10dataParallelRank\x12(\n" +
	"\x10is_cross_encoder\x18\t \x01(\bR\x0eisCrossEncoder\x12\x14\n" +
	"\x05texts\x18\n" +
	" \x03(\tR\x05texts\"\xb9\x01\n" +
	"\rEmbedResponse\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12B\n" +
	"\bcomplete\x18\x02 \x01(\v2$.sglang.grpc.scheduler.EmbedCompleteH\x00R\bcomplete\x129\n" +
	"\x05error\x18\x03 \x01(\v2!.sglang.grpc.scheduler.EmbedErrorH\x00R\x05errorB\n" +
	"\n" +
	"\bresponse\"\xe9\x01\n" +
	"\rEmbedComplete\x12\x1c\n" +
	"\tembedding\x18\x01 \x03(\x02R\tembedding\x12#\n" +
	"\rprompt_tokens\x18\x02 \x01(\x05R\fpromptTokens\x12#\n" +
	"\rcached_tokens\x18\x03 \x01(\x05R\fcachedTokens\x12#\n" +
	"\rembedding_dim\x18\x04 \x01(\x05R\fembeddingDim\x12K\n" +
	"\x10batch_embeddings\x18\x05 \x03(\v2 .sglang.grpc.scheduler.EmbeddingR\x0fbatchEmbeddings\"9\n" +
	"\tEmbedding\x12\x16\n" +
	"\x06values\x18\x01 \x03(\x02R\x06values\x12\x14\n" +
	"\x05index\x18\x02 \x01(\x05R\x05index\"T\n" +
	"\n" +
	"EmbedError\x12\x18\n" +
	"\amessage\x18\x01 \x01(\tR\amessage\x12\x12\n" +
	"\x04code\x18\x02 \x01(\tR\x04code\x12\x18\n" +
	"\adetails\x18\x03 \x01(\tR\adetails\"\x14\n" +
	"\x12HealthCheckRequest\"I\n" +
	"\x13HealthCheckResponse\x12\x18\n" +
	"\ahealthy\x18\x01 \x01(\bR\ahealthy\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\"E\n" +
	"\fAbortRequest\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12\x16\n" +
	"\x06reason\x18\x02 \x01(\tR\x06reason\"C\n" +
	"\rAbortResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\"g\n" +
	"\x0fLoadLoRARequest\x12\x1d\n" +
	"\n" +
	"adapter_id\x18\x01 \x01(\tR\tadapterId\x12!\n" +
	"\fadapter_path\x18\x02 \x01(\tR\vadapterPath\x12\x12\n" +
	"\x04rank\x18\x03 \x01(\x05R\x04rank\"e\n" +
	"\x10LoadLoRAResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x1d\n" +
	"\n" +
	"adapter_id\x18\x02 \x01(\tR\tadapterId\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\"2\n" +
	"\x11UnloadLoRARequest\x12\x1d\n" +
	"\n" +
	"adapter_id\x18\x01 \x01(\tR\tadapterId\"H\n" +
	"\x12UnloadLoRAResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\"\xa4\x01\n" +
	"\x14UpdateWeightsRequest\x12\x1d\n" +
	"\tdisk_path\x18\x01 \x01(\tH\x00R\bdiskPath\x12!\n" +
	"\vtensor_data\x18\x02 \x01(\fH\x00R\n" +
	"tensorData\x12\x1f\n" +
	"\n" +
	"remote_url\x18\x03 \x01(\tH\x00R\tremoteUrl\x12\x1f\n" +
	"\vweight_name\x18\x04 \x01(\tR\n" +
	"weightNameB\b\n" +
	"\x06source\"K\n" +
	"\x15UpdateWeightsResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\"8\n" +
	"\x17GetInternalStateRequest\x12\x1d\n" +
	"\n" +
	"state_keys\x18\x01 \x03(\tR\tstateKeys\"I\n" +
	"\x18GetInternalStateResponse\x12-\n" +
	"\x05state\x18\x01 \x01(\v2\x17.google.protobuf.StructR\x05state\"H\n" +
	"\x17SetInternalStateRequest\x12-\n" +
	"\x05state\x18\x01 \x01(\v2\x17.google.protobuf.StructR\x05state\"N\n" +
	"\x18SetInternalStateResponse\x12\x18\n" +
	"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\"\x15\n" +
	"\x13GetModelInfoRequest\"\xb8\x04\n" +
	"\x14GetModelInfoResponse\x12\x1d\n" +
	"\n" +
	"model_path\x18\x01 \x01(\tR\tmodelPath\x12%\n" +
	"\x0etokenizer_path\x18\x02 \x01(\tR\rtokenizerPath\x12#\n" +
	"\ris_generation\x18\x03 \x01(\bR\fisGeneration\x12:\n" +
	"\x19preferred_sampling_params\x18\x04 \x01(\tR\x17preferredSamplingParams\x12%\n" +
	"\x0eweight_version\x18\x05 \x01(\tR\rweightVersion\x12*\n" +
	"\x11served_model_name\x18\x06 \x01(\tR\x0fservedModelName\x12,\n" +
	"\x12max_context_length\x18\a \x01(\x05R\x10maxContextLength\x12\x1d\n" +
	"\n" +
	"vocab_size\x18\b \x01(\x05R\tvocabSize\x12'\n" +
	"\x0fsupports_vision\x18\t \x01(\bR\x0esupportsVision\x12\x1d\n" +
	"\n" +
	"model_type\x18\n" +
	" \x01(\tR\tmodelType\x12\"\n" +
	"\reos_token_ids\x18\v \x03(\x05R\veosTokenIds\x12 \n" +
	"\fpad_token_id\x18\f \x01(\x05R\n" +
	"padTokenId\x12 \n" +
	"\fbos_token_id\x18\r \x01(\x05R\n" +
	"bosTokenId\x12)\n" +
	"\x11max_req_input_len\x18\x0e \x01(\x05R\x0emaxReqInputLen\"\x16\n" +
	"\x14GetServerInfoRequest\"\xb7\x03\n" +
	"\x15GetServerInfoResponse\x128\n" +
	"\vserver_args\x18\x01 \x01(\v2\x17.google.protobuf.StructR\n" +
	"serverArgs\x12>\n" +
	"\x0escheduler_info\x18\x02 \x01(\v2\x17.google.protobuf.StructR\rschedulerInfo\x12'\n" +
	"\x0factive_requests\x18\x03 \x01(\x05R\x0eactiveRequests\x12\x1b\n" +
	"\tis_paused\x18\x04 \x01(\bR\bisPaused\x124\n" +
	"\x16last_receive_timestamp\x18\x05 \x01(\x01R\x14lastReceiveTimestamp\x12%\n" +
	"\x0euptime_seconds\x18\x06 \x01(\x01R\ruptimeSeconds\x12%\n" +
	"\x0esglang_version\x18\a \x01(\tR\rsglangVersion\x12\x1f\n" +
	"\vserver_type\x18\b \x01(\tR\n" +
	"serverType\x129\n" +
	"\n" +
	"start_time\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\tstartTime2\xd3\x04\n" +
	"\x0fSglangScheduler\x12]\n" +
	"\bGenerate\x12&.sglang.grpc.scheduler.GenerateRequest\x1a'.sglang.grpc.scheduler.GenerateResponse0\x01\x12R\n" +
	"\x05Embed\x12#.sglang.grpc.scheduler.EmbedRequest\x1a$.sglang.grpc.scheduler.EmbedResponse\x12d\n" +
	"\vHealthCheck\x12).sglang.grpc.scheduler.HealthCheckRequest\x1a*.sglang.grpc.scheduler.HealthCheckResponse\x12R\n" +
	"\x05Abort\x12#.sglang.grpc.scheduler.AbortRequest\x1a$.sglang.grpc.scheduler.AbortResponse\x12g\n" +
	"\fGetModelInfo\x12*.sglang.grpc.scheduler.GetModelInfoRequest\x1a+.sglang.grpc.scheduler.GetModelInfoResponse\x12j\n" +
	"\rGetServerInfo\x12+.sglang.grpc.scheduler.GetServerInfoRequest\x1a,.sglang.grpc.scheduler.GetServerInfoResponseb\x06proto3"

var (
	file_sglang_scheduler_proto_rawDescOnce sync.Once
	file_sglang_scheduler_proto_rawDescData []byte
)

func file_sglang_scheduler_proto_rawDescGZIP() []byte {
	file_sglang_scheduler_proto_rawDescOnce.Do(func() {
		file_sglang_scheduler_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_sglang_scheduler_proto_rawDesc), len(file_sglang_scheduler_proto_rawDesc)))
	})
	return file_sglang_scheduler_proto_rawDescData
}

var file_sglang_scheduler_proto_msgTypes = make([]protoimpl.MessageInfo, 38)
var file_sglang_scheduler_proto_goTypes = []any{
	(*SamplingParams)(nil),           // 0: sglang.grpc.scheduler.SamplingParams
	(*DisaggregatedParams)(nil),      // 1: sglang.grpc.scheduler.DisaggregatedParams
	(*GenerateRequest)(nil),          // 2: sglang.grpc.scheduler.GenerateRequest
	(*TokenizedInput)(nil),           // 3: sglang.grpc.scheduler.TokenizedInput
	(*MultimodalInputs)(nil),         // 4: sglang.grpc.scheduler.MultimodalInputs
	(*GenerateResponse)(nil),         // 5: sglang.grpc.scheduler.GenerateResponse
	(*GenerateStreamChunk)(nil),      // 6: sglang.grpc.scheduler.GenerateStreamChunk
	(*GenerateComplete)(nil),         // 7: sglang.grpc.scheduler.GenerateComplete
	(*GenerateError)(nil),            // 8: sglang.grpc.scheduler.GenerateError
	(*OutputLogProbs)(nil),           // 9: sglang.grpc.scheduler.OutputLogProbs
	(*InputLogProbs)(nil),            // 10: sglang.grpc.scheduler.InputLogProbs
	(*InputTokenLogProb)(nil),        // 11: sglang.grpc.scheduler.InputTokenLogProb
	(*TopLogProbs)(nil),              // 12: sglang.grpc.scheduler.TopLogProbs
	(*HiddenStates)(nil),             // 13: sglang.grpc.scheduler.HiddenStates
	(*EmbedRequest)(nil),             // 14: sglang.grpc.scheduler.EmbedRequest
	(*EmbedResponse)(nil),            // 15: sglang.grpc.scheduler.EmbedResponse
	(*EmbedComplete)(nil),            // 16: sglang.grpc.scheduler.EmbedComplete
	(*Embedding)(nil),                // 17: sglang.grpc.scheduler.Embedding
	(*EmbedError)(nil),               // 18: sglang.grpc.scheduler.EmbedError
	(*HealthCheckRequest)(nil),       // 19: sglang.grpc.scheduler.HealthCheckRequest
	(*HealthCheckResponse)(nil),      // 20: sglang.grpc.scheduler.HealthCheckResponse
	(*AbortRequest)(nil),             // 21: sglang.grpc.scheduler.AbortRequest
	(*AbortResponse)(nil),            // 22: sglang.grpc.scheduler.AbortResponse
	(*LoadLoRARequest)(nil),          // 23: sglang.grpc.scheduler.LoadLoRARequest
	(*LoadLoRAResponse)(nil),         // 24: sglang.grpc.scheduler.LoadLoRAResponse
	(*UnloadLoRARequest)(nil),        // 25: sglang.grpc.scheduler.UnloadLoRARequest
	(*UnloadLoRAResponse)(nil),       // 26: sglang.grpc.scheduler.UnloadLoRAResponse
	(*UpdateWeightsRequest)(nil),     // 27: sglang.grpc.scheduler.UpdateWeightsRequest
	(*UpdateWeightsResponse)(nil),    // 28: sglang.grpc.scheduler.UpdateWeightsResponse
	(*GetInternalStateRequest)(nil),  // 29: sglang.grpc.scheduler.GetInternalStateRequest
	(*GetInternalStateResponse)(nil), // 30: sglang.grpc.scheduler.GetInternalStateResponse
	(*SetInternalStateRequest)(nil),  // 31: sglang.grpc.scheduler.SetInternalStateRequest
	(*SetInternalStateResponse)(nil), // 32: sglang.grpc.scheduler.SetInternalStateResponse
	(*GetModelInfoRequest)(nil),      // 33: sglang.grpc.scheduler.GetModelInfoRequest
	(*GetModelInfoResponse)(nil),     // 34: sglang.grpc.scheduler.GetModelInfoResponse
	(*GetServerInfoRequest)(nil),     // 35: sglang.grpc.scheduler.GetServerInfoRequest
	(*GetServerInfoResponse)(nil),    // 36: sglang.grpc.scheduler.GetServerInfoResponse
	nil,                              // 37: sglang.grpc.scheduler.SamplingParams.LogitBiasEntry
	(*structpb.Struct)(nil),          // 38: google.protobuf.Struct
	(*timestamppb.Timestamp)(nil),    // 39: google.protobuf.Timestamp
}
var file_sglang_scheduler_proto_depIdxs = []int32{
	37, // 0: sglang.grpc.scheduler.SamplingParams.logit_bias:type_name -> sglang.grpc.scheduler.SamplingParams.LogitBiasEntry
	38, // 1: sglang.grpc.scheduler.SamplingParams.custom_params:type_name -> google.protobuf.Struct
	3,  // 2: sglang.grpc.scheduler.GenerateRequest.tokenized:type_name -> sglang.grpc.scheduler.TokenizedInput
	4,  // 3: sglang.grpc.scheduler.GenerateRequest.mm_inputs:type_name -> sglang.grpc.scheduler.MultimodalInputs
	0,  // 4: sglang.grpc.scheduler.GenerateRequest.sampling_params:type_name -> sglang.grpc.scheduler.SamplingParams
	1,  // 5: sglang.grpc.scheduler.GenerateRequest.disaggregated_params:type_name -> sglang.grpc.scheduler.DisaggregatedParams
	39, // 6: sglang.grpc.scheduler.GenerateRequest.timestamp:type_name -> google.protobuf.Timestamp
	38, // 7: sglang.grpc.scheduler.MultimodalInputs.processed_features:type_name -> google.protobuf.Struct
	6,  // 8: sglang.grpc.scheduler.GenerateResponse.chunk:type_name -> sglang.grpc.scheduler.GenerateStreamChunk
	7,  // 9: sglang.grpc.scheduler.GenerateResponse.complete:type_name -> sglang.grpc.scheduler.GenerateComplete
	8,  // 10: sglang.grpc.scheduler.GenerateResponse.error:type_name -> sglang.grpc.scheduler.GenerateError
	9,  // 11: sglang.grpc.scheduler.GenerateStreamChunk.output_logprobs:type_name -> sglang.grpc.scheduler.OutputLogProbs
	10, // 12: sglang.grpc.scheduler.GenerateStreamChunk.input_logprobs:type_name -> sglang.grpc.scheduler.InputLogProbs
	9,  // 13: sglang.grpc.scheduler.GenerateComplete.output_logprobs:type_name -> sglang.grpc.scheduler.OutputLogProbs
	13, // 14: sglang.grpc.scheduler.GenerateComplete.all_hidden_states:type_name -> sglang.grpc.scheduler.HiddenStates
	10, // 15: sglang.grpc.scheduler.GenerateComplete.input_logprobs:type_name -> sglang.grpc.scheduler.InputLogProbs
	12, // 16: sglang.grpc.scheduler.OutputLogProbs.top_logprobs:type_name -> sglang.grpc.scheduler.TopLogProbs
	11, // 17: sglang.grpc.scheduler.InputLogProbs.token_logprobs:type_name -> sglang.grpc.scheduler.InputTokenLogProb
	12, // 18: sglang.grpc.scheduler.InputLogProbs.top_logprobs:type_name -> sglang.grpc.scheduler.TopLogProbs
	3,  // 19: sglang.grpc.scheduler.EmbedRequest.tokenized:type_name -> sglang.grpc.scheduler.TokenizedInput
	4,  // 20: sglang.grpc.scheduler.EmbedRequest.mm_inputs:type_name -> sglang.grpc.scheduler.MultimodalInputs
	0,  // 21: sglang.grpc.scheduler.EmbedRequest.sampling_params:type_name -> sglang.grpc.scheduler.SamplingParams
	16, // 22: sglang.grpc.scheduler.EmbedResponse.complete:type_name -> sglang.grpc.scheduler.EmbedComplete
	18, // 23: sglang.grpc.scheduler.EmbedResponse.error:type_name -> sglang.grpc.scheduler.EmbedError
	17, // 24: sglang.grpc.scheduler.EmbedComplete.batch_embeddings:type_name -> sglang.grpc.scheduler.Embedding
	38, // 25: sglang.grpc.scheduler.GetInternalStateResponse.state:type_name -> google.protobuf.Struct
	38, // 26: sglang.grpc.scheduler.SetInternalStateRequest.state:type_name -> google.protobuf.Struct
	38, // 27: sglang.grpc.scheduler.GetServerInfoResponse.server_args:type_name -> google.protobuf.Struct
	38, // 28: sglang.grpc.scheduler.GetServerInfoResponse.scheduler_info:type_name -> google.protobuf.Struct
	39, // 29: sglang.grpc.scheduler.GetServerInfoResponse.start_time:type_name -> google.protobuf.Timestamp
	2,  // 30: sglang.grpc.scheduler.SglangScheduler.Generate:input_type -> sglang.grpc.scheduler.GenerateRequest
	14, // 31: sglang.grpc.scheduler.SglangScheduler.Embed:input_type -> sglang.grpc.scheduler.EmbedRequest
	19, // 32: sglang.grpc.scheduler.SglangScheduler.HealthCheck:input_type -> sglang.grpc.scheduler.HealthCheckRequest
	21, // 33: sglang.grpc.scheduler.SglangScheduler.Abort:input_type -> sglang.grpc.scheduler.AbortRequest
	33, // 34: sglang.grpc.scheduler.SglangScheduler.GetModelInfo:input_type -> sglang.grpc.scheduler.GetModelInfoRequest
	35, // 35: sglang.grpc.scheduler.SglangScheduler.GetServerInfo:input_type -> sglang.grpc.scheduler.GetServerInfoRequest
	5,  // 36: sglang.grpc.scheduler.SglangScheduler.Generate:output_type -> sglang.grpc.scheduler.GenerateResponse
	15, // 37: sglang.grpc.scheduler.SglangScheduler.Embed:output_type -> sglang.grpc.scheduler.EmbedResponse
	20, // 38: sglang.grpc.scheduler.SglangScheduler.HealthCheck:output_type -> sglang.grpc.scheduler.HealthCheckResponse
	22, // 39: sglang.grpc.scheduler.SglangScheduler.Abort:output_type -> sglang.grpc.scheduler.AbortResponse
	34, // 40: sglang.grpc.scheduler.SglangScheduler.GetModelInfo:output_type -> sglang.grpc.scheduler.GetModelInfoResponse
	36, // 41: sglang.grpc.scheduler.SglangScheduler.GetServerInfo:output_type -> sglang.grpc.scheduler.GetServerInfoResponse
	36, // [36:42] is the sub-list for method output_type
	30, // [30:36] is the sub-list for method input_type
	30, // [30:30] is the sub-list for extension type_name
	30, // [30:30] is the sub-list for extension extendee
	0,  // [0:30] is the sub-list for field type_name
}

func init() { file_sglang_scheduler_proto_init() }
func file_sglang_scheduler_proto_init() {
	if File_sglang_scheduler_proto != nil {
		return
	}
	file_sglang_scheduler_proto_msgTypes[0].OneofWrappers = []any{
		(*SamplingParams_Regex)(nil),
		(*SamplingParams_JsonSchema)(nil),
		(*SamplingParams_EbnfGrammar)(nil),
		(*SamplingParams_StructuralTag)(nil),
	}
	file_sglang_scheduler_proto_msgTypes[5].OneofWrappers = []any{
		(*GenerateResponse_Chunk)(nil),
		(*GenerateResponse_Complete)(nil),
		(*GenerateResponse_Error)(nil),
	}
	file_sglang_scheduler_proto_msgTypes[7].OneofWrappers = []any{
		(*GenerateComplete_MatchedTokenId)(nil),
		(*GenerateComplete_MatchedStopStr)(nil),
	}
	file_sglang_scheduler_proto_msgTypes[11].OneofWrappers = []any{}
	file_sglang_scheduler_proto_msgTypes[15].OneofWrappers = []any{
		(*EmbedResponse_Complete)(nil),
		(*EmbedResponse_Error)(nil),
	}
	file_sglang_scheduler_proto_msgTypes[27].OneofWrappers = []any{
		(*UpdateWeightsRequest_DiskPath)(nil),
		(*UpdateWeightsRequest_TensorData)(nil),
		(*UpdateWeightsRequest_RemoteUrl)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_sglang_scheduler_proto_rawDesc), len(file_sglang_scheduler_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   38,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_sglang_scheduler_proto_goTypes,
		DependencyIndexes: file_sglang_scheduler_proto_depIdxs,
		MessageInfos:      file_sglang_scheduler_proto_msgTypes,
	}.Build()
	File_sglang_scheduler_proto = out.File
	file_sglang_scheduler_proto_goTypes = nil
	file_sglang_scheduler_proto_depIdxs = nil
}