// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.2
// source: generator.proto

package ragv1

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

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

// GenerateRequest for LLM generation
type GenerateRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// System prompt
	SystemPrompt string `protobuf:"bytes,1,opt,name=system_prompt,json=systemPrompt,proto3" json:"system_prompt,omitempty"`
	// User query/prompt
	Prompt string `protobuf:"bytes,2,opt,name=prompt,proto3" json:"prompt,omitempty"`
	// Context from retrieved documents
	Context []*ContextDocument `protobuf:"bytes,3,rep,name=context,proto3" json:"context,omitempty"`
	// Conversation history
	History []*ChatMessage `protobuf:"bytes,4,rep,name=history,proto3" json:"history,omitempty"`
	// Generation configuration
	Config        *GenerateConfig `protobuf:"bytes,5,opt,name=config,proto3" json:"config,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GenerateRequest) Reset() {
	*x = GenerateRequest{}
	mi := &file_generator_proto_msgTypes[0]
	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_generator_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 GenerateRequest.ProtoReflect.Descriptor instead.
func (*GenerateRequest) Descriptor() ([]byte, []int) {
	return file_generator_proto_rawDescGZIP(), []int{0}
}

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

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

func (x *GenerateRequest) GetContext() []*ContextDocument {
	if x != nil {
		return x.Context
	}
	return nil
}

func (x *GenerateRequest) GetHistory() []*ChatMessage {
	if x != nil {
		return x.History
	}
	return nil
}

func (x *GenerateRequest) GetConfig() *GenerateConfig {
	if x != nil {
		return x.Config
	}
	return nil
}

// ContextDocument represents retrieved context
type ContextDocument struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Document content
	Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	// Document title
	Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	// Source reference
	Source string `protobuf:"bytes,3,opt,name=source,proto3" json:"source,omitempty"`
	// Relevance score
	Score         float32 `protobuf:"fixed32,4,opt,name=score,proto3" json:"score,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ContextDocument) ProtoMessage() {}

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

func (x *ContextDocument) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

func (x *ContextDocument) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *ContextDocument) GetSource() string {
	if x != nil {
		return x.Source
	}
	return ""
}

func (x *ContextDocument) GetScore() float32 {
	if x != nil {
		return x.Score
	}
	return 0
}

// ChatMessage for conversation history
type ChatMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Role: user, assistant, system
	Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
	// Message content
	Content       string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ChatMessage) ProtoMessage() {}

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

func (x *ChatMessage) GetRole() string {
	if x != nil {
		return x.Role
	}
	return ""
}

func (x *ChatMessage) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

// GenerateConfig for generation parameters
type GenerateConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Model to use
	Model string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
	// Temperature (0.0 - 2.0)
	Temperature float32 `protobuf:"fixed32,2,opt,name=temperature,proto3" json:"temperature,omitempty"`
	// Maximum tokens to generate
	MaxTokens int32 `protobuf:"varint,3,opt,name=max_tokens,json=maxTokens,proto3" json:"max_tokens,omitempty"`
	// Top-p sampling
	TopP float32 `protobuf:"fixed32,4,opt,name=top_p,json=topP,proto3" json:"top_p,omitempty"`
	// Frequency penalty
	FrequencyPenalty float32 `protobuf:"fixed32,5,opt,name=frequency_penalty,json=frequencyPenalty,proto3" json:"frequency_penalty,omitempty"`
	// Presence penalty
	PresencePenalty float32 `protobuf:"fixed32,6,opt,name=presence_penalty,json=presencePenalty,proto3" json:"presence_penalty,omitempty"`
	// Stop sequences
	StopSequences []string `protobuf:"bytes,7,rep,name=stop_sequences,json=stopSequences,proto3" json:"stop_sequences,omitempty"`
	// Response format: text, json
	ResponseFormat string `protobuf:"bytes,8,opt,name=response_format,json=responseFormat,proto3" json:"response_format,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*GenerateConfig) ProtoMessage() {}

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

func (x *GenerateConfig) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

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

func (x *GenerateConfig) GetMaxTokens() int32 {
	if x != nil {
		return x.MaxTokens
	}
	return 0
}

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

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

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

func (x *GenerateConfig) GetStopSequences() []string {
	if x != nil {
		return x.StopSequences
	}
	return nil
}

func (x *GenerateConfig) GetResponseFormat() string {
	if x != nil {
		return x.ResponseFormat
	}
	return ""
}

// GenerateResponse contains the generated text
type GenerateResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Generated text
	Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
	// Token usage
	Usage *TokenUsage `protobuf:"bytes,2,opt,name=usage,proto3" json:"usage,omitempty"`
	// Finish reason: stop, length, content_filter
	FinishReason string `protobuf:"bytes,3,opt,name=finish_reason,json=finishReason,proto3" json:"finish_reason,omitempty"`
	// Model used
	Model string `protobuf:"bytes,4,opt,name=model,proto3" json:"model,omitempty"`
	// Generation metadata
	Metadata      *GenerateMetadata `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GenerateResponse) Reset() {
	*x = GenerateResponse{}
	mi := &file_generator_proto_msgTypes[4]
	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_generator_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 GenerateResponse.ProtoReflect.Descriptor instead.
func (*GenerateResponse) Descriptor() ([]byte, []int) {
	return file_generator_proto_rawDescGZIP(), []int{4}
}

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

func (x *GenerateResponse) GetUsage() *TokenUsage {
	if x != nil {
		return x.Usage
	}
	return nil
}

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

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

func (x *GenerateResponse) GetMetadata() *GenerateMetadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

// TokenUsage tracks token consumption
type TokenUsage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Prompt tokens
	PromptTokens int32 `protobuf:"varint,1,opt,name=prompt_tokens,json=promptTokens,proto3" json:"prompt_tokens,omitempty"`
	// Completion tokens
	CompletionTokens int32 `protobuf:"varint,2,opt,name=completion_tokens,json=completionTokens,proto3" json:"completion_tokens,omitempty"`
	// Total tokens
	TotalTokens int32 `protobuf:"varint,3,opt,name=total_tokens,json=totalTokens,proto3" json:"total_tokens,omitempty"`
	// Estimated cost in USD
	EstimatedCost float32 `protobuf:"fixed32,4,opt,name=estimated_cost,json=estimatedCost,proto3" json:"estimated_cost,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TokenUsage) ProtoMessage() {}

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

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

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

func (x *TokenUsage) GetTotalTokens() int32 {
	if x != nil {
		return x.TotalTokens
	}
	return 0
}

func (x *TokenUsage) GetEstimatedCost() float32 {
	if x != nil {
		return x.EstimatedCost
	}
	return 0
}

// GenerateMetadata for generation info
type GenerateMetadata struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Latency in milliseconds
	LatencyMs int64 `protobuf:"varint,1,opt,name=latency_ms,json=latencyMs,proto3" json:"latency_ms,omitempty"`
	// Provider used
	Provider string `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider,omitempty"`
	// Trace ID
	TraceId       string `protobuf:"bytes,3,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GenerateMetadata) ProtoMessage() {}

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

func (x *GenerateMetadata) GetLatencyMs() int64 {
	if x != nil {
		return x.LatencyMs
	}
	return 0
}

func (x *GenerateMetadata) GetProvider() string {
	if x != nil {
		return x.Provider
	}
	return ""
}

func (x *GenerateMetadata) GetTraceId() string {
	if x != nil {
		return x.TraceId
	}
	return ""
}

// GenerateChunk for streaming responses
type GenerateChunk struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Text delta
	Delta string `protobuf:"bytes,1,opt,name=delta,proto3" json:"delta,omitempty"`
	// Is this the final chunk?
	IsFinal bool `protobuf:"varint,2,opt,name=is_final,json=isFinal,proto3" json:"is_final,omitempty"`
	// Token usage (in final chunk)
	Usage *TokenUsage `protobuf:"bytes,3,opt,name=usage,proto3" json:"usage,omitempty"`
	// Finish reason (in final chunk)
	FinishReason  string `protobuf:"bytes,4,opt,name=finish_reason,json=finishReason,proto3" json:"finish_reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GenerateChunk) ProtoMessage() {}

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

func (x *GenerateChunk) GetDelta() string {
	if x != nil {
		return x.Delta
	}
	return ""
}

func (x *GenerateChunk) GetIsFinal() bool {
	if x != nil {
		return x.IsFinal
	}
	return false
}

func (x *GenerateChunk) GetUsage() *TokenUsage {
	if x != nil {
		return x.Usage
	}
	return nil
}

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

// EmbeddingRequest for generating embeddings
type EmbeddingRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Text to embed
	Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
	// Model to use
	Model string `protobuf:"bytes,2,opt,name=model,proto3" json:"model,omitempty"`
	// Embedding dimensions (if configurable)
	Dimensions    int32 `protobuf:"varint,3,opt,name=dimensions,proto3" json:"dimensions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EmbeddingRequest) ProtoMessage() {}

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

func (x *EmbeddingRequest) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

func (x *EmbeddingRequest) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

func (x *EmbeddingRequest) GetDimensions() int32 {
	if x != nil {
		return x.Dimensions
	}
	return 0
}

// EmbeddingResponse contains the embedding
type EmbeddingResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Embedding vector
	Embedding []float32 `protobuf:"fixed32,1,rep,packed,name=embedding,proto3" json:"embedding,omitempty"`
	// Model used
	Model string `protobuf:"bytes,2,opt,name=model,proto3" json:"model,omitempty"`
	// Token usage
	Tokens int32 `protobuf:"varint,3,opt,name=tokens,proto3" json:"tokens,omitempty"`
	// Dimensions
	Dimensions    int32 `protobuf:"varint,4,opt,name=dimensions,proto3" json:"dimensions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EmbeddingResponse) ProtoMessage() {}

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

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

func (x *EmbeddingResponse) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

func (x *EmbeddingResponse) GetTokens() int32 {
	if x != nil {
		return x.Tokens
	}
	return 0
}

func (x *EmbeddingResponse) GetDimensions() int32 {
	if x != nil {
		return x.Dimensions
	}
	return 0
}

// BatchEmbeddingRequest for bulk embeddings
type BatchEmbeddingRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Texts to embed
	Texts []string `protobuf:"bytes,1,rep,name=texts,proto3" json:"texts,omitempty"`
	// Model to use
	Model string `protobuf:"bytes,2,opt,name=model,proto3" json:"model,omitempty"`
	// Embedding dimensions
	Dimensions    int32 `protobuf:"varint,3,opt,name=dimensions,proto3" json:"dimensions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchEmbeddingRequest) ProtoMessage() {}

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

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

func (x *BatchEmbeddingRequest) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

func (x *BatchEmbeddingRequest) GetDimensions() int32 {
	if x != nil {
		return x.Dimensions
	}
	return 0
}

// BatchEmbeddingResponse for bulk embeddings
type BatchEmbeddingResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Embeddings
	Embeddings []*EmbeddingResult `protobuf:"bytes,1,rep,name=embeddings,proto3" json:"embeddings,omitempty"`
	// Total tokens used
	TotalTokens int32 `protobuf:"varint,2,opt,name=total_tokens,json=totalTokens,proto3" json:"total_tokens,omitempty"`
	// Model used
	Model         string `protobuf:"bytes,3,opt,name=model,proto3" json:"model,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BatchEmbeddingResponse) ProtoMessage() {}

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

func (x *BatchEmbeddingResponse) GetEmbeddings() []*EmbeddingResult {
	if x != nil {
		return x.Embeddings
	}
	return nil
}

func (x *BatchEmbeddingResponse) GetTotalTokens() int32 {
	if x != nil {
		return x.TotalTokens
	}
	return 0
}

func (x *BatchEmbeddingResponse) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

// EmbeddingResult for individual embedding
type EmbeddingResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Index in the batch
	Index int32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// Embedding vector
	Embedding []float32 `protobuf:"fixed32,2,rep,packed,name=embedding,proto3" json:"embedding,omitempty"`
	// Tokens used
	Tokens        int32 `protobuf:"varint,3,opt,name=tokens,proto3" json:"tokens,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EmbeddingResult) ProtoMessage() {}

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

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

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

func (x *EmbeddingResult) GetTokens() int32 {
	if x != nil {
		return x.Tokens
	}
	return 0
}

// RerankRequest for document reranking
type RerankRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Query for relevance scoring
	Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	// Documents to rerank
	Documents []*RerankDocument `protobuf:"bytes,2,rep,name=documents,proto3" json:"documents,omitempty"`
	// Number of top results to return
	TopN int32 `protobuf:"varint,3,opt,name=top_n,json=topN,proto3" json:"top_n,omitempty"`
	// Model to use for reranking
	Model         string `protobuf:"bytes,4,opt,name=model,proto3" json:"model,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RerankRequest) ProtoMessage() {}

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

func (x *RerankRequest) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *RerankRequest) GetDocuments() []*RerankDocument {
	if x != nil {
		return x.Documents
	}
	return nil
}

func (x *RerankRequest) GetTopN() int32 {
	if x != nil {
		return x.TopN
	}
	return 0
}

func (x *RerankRequest) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

// RerankDocument for reranking input
type RerankDocument struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Document ID
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Document content
	Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	// Original score (optional)
	OriginalScore float32 `protobuf:"fixed32,3,opt,name=original_score,json=originalScore,proto3" json:"original_score,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RerankDocument) ProtoMessage() {}

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

func (x *RerankDocument) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *RerankDocument) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

func (x *RerankDocument) GetOriginalScore() float32 {
	if x != nil {
		return x.OriginalScore
	}
	return 0
}

// RerankResponse contains reranked documents
type RerankResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Reranked results
	Results []*RerankResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	// Model used
	Model         string `protobuf:"bytes,2,opt,name=model,proto3" json:"model,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RerankResponse) ProtoMessage() {}

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

func (x *RerankResponse) GetResults() []*RerankResult {
	if x != nil {
		return x.Results
	}
	return nil
}

func (x *RerankResponse) GetModel() string {
	if x != nil {
		return x.Model
	}
	return ""
}

// RerankResult for reranked document
type RerankResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Document ID
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// New relevance score
	Score float32 `protobuf:"fixed32,2,opt,name=score,proto3" json:"score,omitempty"`
	// New rank position
	Rank int32 `protobuf:"varint,3,opt,name=rank,proto3" json:"rank,omitempty"`
	// Original rank position
	OriginalRank  int32 `protobuf:"varint,4,opt,name=original_rank,json=originalRank,proto3" json:"original_rank,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RerankResult) ProtoMessage() {}

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

func (x *RerankResult) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *RerankResult) GetScore() float32 {
	if x != nil {
		return x.Score
	}
	return 0
}

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

func (x *RerankResult) GetOriginalRank() int32 {
	if x != nil {
		return x.OriginalRank
	}
	return 0
}

var File_generator_proto protoreflect.FileDescriptor

const file_generator_proto_rawDesc = "" +
	"\n" +
	"\x0fgenerator.proto\x12\x06rag.v1\"\xe0\x01\n" +
	"\x0fGenerateRequest\x12#\n" +
	"\rsystem_prompt\x18\x01 \x01(\tR\fsystemPrompt\x12\x16\n" +
	"\x06prompt\x18\x02 \x01(\tR\x06prompt\x121\n" +
	"\acontext\x18\x03 \x03(\v2\x17.rag.v1.ContextDocumentR\acontext\x12-\n" +
	"\ahistory\x18\x04 \x03(\v2\x13.rag.v1.ChatMessageR\ahistory\x12.\n" +
	"\x06config\x18\x05 \x01(\v2\x16.rag.v1.GenerateConfigR\x06config\"o\n" +
	"\x0fContextDocument\x12\x18\n" +
	"\acontent\x18\x01 \x01(\tR\acontent\x12\x14\n" +
	"\x05title\x18\x02 \x01(\tR\x05title\x12\x16\n" +
	"\x06source\x18\x03 \x01(\tR\x06source\x12\x14\n" +
	"\x05score\x18\x04 \x01(\x02R\x05score\";\n" +
	"\vChatMessage\x12\x12\n" +
	"\x04role\x18\x01 \x01(\tR\x04role\x12\x18\n" +
	"\acontent\x18\x02 \x01(\tR\acontent\"\xa4\x02\n" +
	"\x0eGenerateConfig\x12\x14\n" +
	"\x05model\x18\x01 \x01(\tR\x05model\x12 \n" +
	"\vtemperature\x18\x02 \x01(\x02R\vtemperature\x12\x1d\n" +
	"\n" +
	"max_tokens\x18\x03 \x01(\x05R\tmaxTokens\x12\x13\n" +
	"\x05top_p\x18\x04 \x01(\x02R\x04topP\x12+\n" +
	"\x11frequency_penalty\x18\x05 \x01(\x02R\x10frequencyPenalty\x12)\n" +
	"\x10presence_penalty\x18\x06 \x01(\x02R\x0fpresencePenalty\x12%\n" +
	"\x0estop_sequences\x18\a \x03(\tR\rstopSequences\x12'\n" +
	"\x0fresponse_format\x18\b \x01(\tR\x0eresponseFormat\"\xc1\x01\n" +
	"\x10GenerateResponse\x12\x12\n" +
	"\x04text\x18\x01 \x01(\tR\x04text\x12(\n" +
	"\x05usage\x18\x02 \x01(\v2\x12.rag.v1.TokenUsageR\x05usage\x12#\n" +
	"\rfinish_reason\x18\x03 \x01(\tR\ffinishReason\x12\x14\n" +
	"\x05model\x18\x04 \x01(\tR\x05model\x124\n" +
	"\bmetadata\x18\x05 \x01(\v2\x18.rag.v1.GenerateMetadataR\bmetadata\"\xa8\x01\n" +
	"\n" +
	"TokenUsage\x12#\n" +
	"\rprompt_tokens\x18\x01 \x01(\x05R\fpromptTokens\x12+\n" +
	"\x11completion_tokens\x18\x02 \x01(\x05R\x10completionTokens\x12!\n" +
	"\ftotal_tokens\x18\x03 \x01(\x05R\vtotalTokens\x12%\n" +
	"\x0eestimated_cost\x18\x04 \x01(\x02R\restimatedCost\"h\n" +
	"\x10GenerateMetadata\x12\x1d\n" +
	"\n" +
	"latency_ms\x18\x01 \x01(\x03R\tlatencyMs\x12\x1a\n" +
	"\bprovider\x18\x02 \x01(\tR\bprovider\x12\x19\n" +
	"\btrace_id\x18\x03 \x01(\tR\atraceId\"\x8f\x01\n" +
	"\rGenerateChunk\x12\x14\n" +
	"\x05delta\x18\x01 \x01(\tR\x05delta\x12\x19\n" +
	"\bis_final\x18\x02 \x01(\bR\aisFinal\x12(\n" +
	"\x05usage\x18\x03 \x01(\v2\x12.rag.v1.TokenUsageR\x05usage\x12#\n" +
	"\rfinish_reason\x18\x04 \x01(\tR\ffinishReason\"\\\n" +
	"\x10EmbeddingRequest\x12\x12\n" +
	"\x04text\x18\x01 \x01(\tR\x04text\x12\x14\n" +
	"\x05model\x18\x02 \x01(\tR\x05model\x12\x1e\n" +
	"\n" +
	"dimensions\x18\x03 \x01(\x05R\n" +
	"dimensions\"\x7f\n" +
	"\x11EmbeddingResponse\x12\x1c\n" +
	"\tembedding\x18\x01 \x03(\x02R\tembedding\x12\x14\n" +
	"\x05model\x18\x02 \x01(\tR\x05model\x12\x16\n" +
	"\x06tokens\x18\x03 \x01(\x05R\x06tokens\x12\x1e\n" +
	"\n" +
	"dimensions\x18\x04 \x01(\x05R\n" +
	"dimensions\"c\n" +
	"\x15BatchEmbeddingRequest\x12\x14\n" +
	"\x05texts\x18\x01 \x03(\tR\x05texts\x12\x14\n" +
	"\x05model\x18\x02 \x01(\tR\x05model\x12\x1e\n" +
	"\n" +
	"dimensions\x18\x03 \x01(\x05R\n" +
	"dimensions\"\x8a\x01\n" +
	"\x16BatchEmbeddingResponse\x127\n" +
	"\n" +
	"embeddings\x18\x01 \x03(\v2\x17.rag.v1.EmbeddingResultR\n" +
	"embeddings\x12!\n" +
	"\ftotal_tokens\x18\x02 \x01(\x05R\vtotalTokens\x12\x14\n" +
	"\x05model\x18\x03 \x01(\tR\x05model\"]\n" +
	"\x0fEmbeddingResult\x12\x14\n" +
	"\x05index\x18\x01 \x01(\x05R\x05index\x12\x1c\n" +
	"\tembedding\x18\x02 \x03(\x02R\tembedding\x12\x16\n" +
	"\x06tokens\x18\x03 \x01(\x05R\x06tokens\"\x86\x01\n" +
	"\rRerankRequest\x12\x14\n" +
	"\x05query\x18\x01 \x01(\tR\x05query\x124\n" +
	"\tdocuments\x18\x02 \x03(\v2\x16.rag.v1.RerankDocumentR\tdocuments\x12\x13\n" +
	"\x05top_n\x18\x03 \x01(\x05R\x04topN\x12\x14\n" +
	"\x05model\x18\x04 \x01(\tR\x05model\"a\n" +
	"\x0eRerankDocument\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n" +
	"\acontent\x18\x02 \x01(\tR\acontent\x12%\n" +
	"\x0eoriginal_score\x18\x03 \x01(\x02R\roriginalScore\"V\n" +
	"\x0eRerankResponse\x12.\n" +
	"\aresults\x18\x01 \x03(\v2\x14.rag.v1.RerankResultR\aresults\x12\x14\n" +
	"\x05model\x18\x02 \x01(\tR\x05model\"m\n" +
	"\fRerankResult\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +
	"\x05score\x18\x02 \x01(\x02R\x05score\x12\x12\n" +
	"\x04rank\x18\x03 \x01(\x05R\x04rank\x12#\n" +
	"\roriginal_rank\x18\x04 \x01(\x05R\foriginalRank2\xf2\x02\n" +
	"\x10GeneratorService\x12=\n" +
	"\bGenerate\x12\x17.rag.v1.GenerateRequest\x1a\x18.rag.v1.GenerateResponse\x12B\n" +
	"\x0eGenerateStream\x12\x17.rag.v1.GenerateRequest\x1a\x15.rag.v1.GenerateChunk0\x01\x12H\n" +
	"\x11GenerateEmbedding\x12\x18.rag.v1.EmbeddingRequest\x1a\x19.rag.v1.EmbeddingResponse\x12X\n" +
	"\x17BatchGenerateEmbeddings\x12\x1d.rag.v1.BatchEmbeddingRequest\x1a\x1e.rag.v1.BatchEmbeddingResponse\x127\n" +
	"\x06Rerank\x12\x15.rag.v1.RerankRequest\x1a\x16.rag.v1.RerankResponseB6Z4github.com/AmaniQuery/amaniquery/pkg/proto/gen/ragv1b\x06proto3"

var (
	file_generator_proto_rawDescOnce sync.Once
	file_generator_proto_rawDescData []byte
)

func file_generator_proto_rawDescGZIP() []byte {
	file_generator_proto_rawDescOnce.Do(func() {
		file_generator_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_generator_proto_rawDesc), len(file_generator_proto_rawDesc)))
	})
	return file_generator_proto_rawDescData
}

var file_generator_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
var file_generator_proto_goTypes = []any{
	(*GenerateRequest)(nil),        // 0: rag.v1.GenerateRequest
	(*ContextDocument)(nil),        // 1: rag.v1.ContextDocument
	(*ChatMessage)(nil),            // 2: rag.v1.ChatMessage
	(*GenerateConfig)(nil),         // 3: rag.v1.GenerateConfig
	(*GenerateResponse)(nil),       // 4: rag.v1.GenerateResponse
	(*TokenUsage)(nil),             // 5: rag.v1.TokenUsage
	(*GenerateMetadata)(nil),       // 6: rag.v1.GenerateMetadata
	(*GenerateChunk)(nil),          // 7: rag.v1.GenerateChunk
	(*EmbeddingRequest)(nil),       // 8: rag.v1.EmbeddingRequest
	(*EmbeddingResponse)(nil),      // 9: rag.v1.EmbeddingResponse
	(*BatchEmbeddingRequest)(nil),  // 10: rag.v1.BatchEmbeddingRequest
	(*BatchEmbeddingResponse)(nil), // 11: rag.v1.BatchEmbeddingResponse
	(*EmbeddingResult)(nil),        // 12: rag.v1.EmbeddingResult
	(*RerankRequest)(nil),          // 13: rag.v1.RerankRequest
	(*RerankDocument)(nil),         // 14: rag.v1.RerankDocument
	(*RerankResponse)(nil),         // 15: rag.v1.RerankResponse
	(*RerankResult)(nil),           // 16: rag.v1.RerankResult
}
var file_generator_proto_depIdxs = []int32{
	1,  // 0: rag.v1.GenerateRequest.context:type_name -> rag.v1.ContextDocument
	2,  // 1: rag.v1.GenerateRequest.history:type_name -> rag.v1.ChatMessage
	3,  // 2: rag.v1.GenerateRequest.config:type_name -> rag.v1.GenerateConfig
	5,  // 3: rag.v1.GenerateResponse.usage:type_name -> rag.v1.TokenUsage
	6,  // 4: rag.v1.GenerateResponse.metadata:type_name -> rag.v1.GenerateMetadata
	5,  // 5: rag.v1.GenerateChunk.usage:type_name -> rag.v1.TokenUsage
	12, // 6: rag.v1.BatchEmbeddingResponse.embeddings:type_name -> rag.v1.EmbeddingResult
	14, // 7: rag.v1.RerankRequest.documents:type_name -> rag.v1.RerankDocument
	16, // 8: rag.v1.RerankResponse.results:type_name -> rag.v1.RerankResult
	0,  // 9: rag.v1.GeneratorService.Generate:input_type -> rag.v1.GenerateRequest
	0,  // 10: rag.v1.GeneratorService.GenerateStream:input_type -> rag.v1.GenerateRequest
	8,  // 11: rag.v1.GeneratorService.GenerateEmbedding:input_type -> rag.v1.EmbeddingRequest
	10, // 12: rag.v1.GeneratorService.BatchGenerateEmbeddings:input_type -> rag.v1.BatchEmbeddingRequest
	13, // 13: rag.v1.GeneratorService.Rerank:input_type -> rag.v1.RerankRequest
	4,  // 14: rag.v1.GeneratorService.Generate:output_type -> rag.v1.GenerateResponse
	7,  // 15: rag.v1.GeneratorService.GenerateStream:output_type -> rag.v1.GenerateChunk
	9,  // 16: rag.v1.GeneratorService.GenerateEmbedding:output_type -> rag.v1.EmbeddingResponse
	11, // 17: rag.v1.GeneratorService.BatchGenerateEmbeddings:output_type -> rag.v1.BatchEmbeddingResponse
	15, // 18: rag.v1.GeneratorService.Rerank:output_type -> rag.v1.RerankResponse
	14, // [14:19] is the sub-list for method output_type
	9,  // [9:14] is the sub-list for method input_type
	9,  // [9:9] is the sub-list for extension type_name
	9,  // [9:9] is the sub-list for extension extendee
	0,  // [0:9] is the sub-list for field type_name
}

func init() { file_generator_proto_init() }
func file_generator_proto_init() {
	if File_generator_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_generator_proto_rawDesc), len(file_generator_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   17,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_generator_proto_goTypes,
		DependencyIndexes: file_generator_proto_depIdxs,
		MessageInfos:      file_generator_proto_msgTypes,
	}.Build()
	File_generator_proto = out.File
	file_generator_proto_goTypes = nil
	file_generator_proto_depIdxs = nil
}