// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.2
// source: agent.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)
)

// ChunkType defines the type of streaming chunk
type ChunkType int32

const (
	ChunkType_CHUNK_TYPE_UNSPECIFIED ChunkType = 0
	ChunkType_CHUNK_TYPE_THINKING    ChunkType = 1
	ChunkType_CHUNK_TYPE_RETRIEVAL   ChunkType = 2
	ChunkType_CHUNK_TYPE_GENERATION  ChunkType = 3
	ChunkType_CHUNK_TYPE_COMPLETE    ChunkType = 4
	ChunkType_CHUNK_TYPE_ERROR       ChunkType = 5
)

// Enum value maps for ChunkType.
var (
	ChunkType_name = map[int32]string{
		0: "CHUNK_TYPE_UNSPECIFIED",
		1: "CHUNK_TYPE_THINKING",
		2: "CHUNK_TYPE_RETRIEVAL",
		3: "CHUNK_TYPE_GENERATION",
		4: "CHUNK_TYPE_COMPLETE",
		5: "CHUNK_TYPE_ERROR",
	}
	ChunkType_value = map[string]int32{
		"CHUNK_TYPE_UNSPECIFIED": 0,
		"CHUNK_TYPE_THINKING":    1,
		"CHUNK_TYPE_RETRIEVAL":   2,
		"CHUNK_TYPE_GENERATION":  3,
		"CHUNK_TYPE_COMPLETE":    4,
		"CHUNK_TYPE_ERROR":       5,
	}
)

func (x ChunkType) Enum() *ChunkType {
	p := new(ChunkType)
	*p = x
	return p
}

func (x ChunkType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ChunkType) Descriptor() protoreflect.EnumDescriptor {
	return file_agent_proto_enumTypes[0].Descriptor()
}

func (ChunkType) Type() protoreflect.EnumType {
	return &file_agent_proto_enumTypes[0]
}

func (x ChunkType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ChunkType.Descriptor instead.
func (ChunkType) EnumDescriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{0}
}

// MessageRole defines who sent the message
type MessageRole int32

const (
	MessageRole_MESSAGE_ROLE_UNSPECIFIED MessageRole = 0
	MessageRole_MESSAGE_ROLE_USER        MessageRole = 1
	MessageRole_MESSAGE_ROLE_ASSISTANT   MessageRole = 2
	MessageRole_MESSAGE_ROLE_SYSTEM      MessageRole = 3
)

// Enum value maps for MessageRole.
var (
	MessageRole_name = map[int32]string{
		0: "MESSAGE_ROLE_UNSPECIFIED",
		1: "MESSAGE_ROLE_USER",
		2: "MESSAGE_ROLE_ASSISTANT",
		3: "MESSAGE_ROLE_SYSTEM",
	}
	MessageRole_value = map[string]int32{
		"MESSAGE_ROLE_UNSPECIFIED": 0,
		"MESSAGE_ROLE_USER":        1,
		"MESSAGE_ROLE_ASSISTANT":   2,
		"MESSAGE_ROLE_SYSTEM":      3,
	}
)

func (x MessageRole) Enum() *MessageRole {
	p := new(MessageRole)
	*p = x
	return p
}

func (x MessageRole) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (MessageRole) Descriptor() protoreflect.EnumDescriptor {
	return file_agent_proto_enumTypes[1].Descriptor()
}

func (MessageRole) Type() protoreflect.EnumType {
	return &file_agent_proto_enumTypes[1]
}

func (x MessageRole) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use MessageRole.Descriptor instead.
func (MessageRole) EnumDescriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{1}
}

// StepType defines execution step types
type StepType int32

const (
	StepType_STEP_TYPE_UNSPECIFIED StepType = 0
	StepType_STEP_TYPE_SEARCH      StepType = 1
	StepType_STEP_TYPE_ANALYZE     StepType = 2
	StepType_STEP_TYPE_SYNTHESIZE  StepType = 3
	StepType_STEP_TYPE_VALIDATE    StepType = 4
)

// Enum value maps for StepType.
var (
	StepType_name = map[int32]string{
		0: "STEP_TYPE_UNSPECIFIED",
		1: "STEP_TYPE_SEARCH",
		2: "STEP_TYPE_ANALYZE",
		3: "STEP_TYPE_SYNTHESIZE",
		4: "STEP_TYPE_VALIDATE",
	}
	StepType_value = map[string]int32{
		"STEP_TYPE_UNSPECIFIED": 0,
		"STEP_TYPE_SEARCH":      1,
		"STEP_TYPE_ANALYZE":     2,
		"STEP_TYPE_SYNTHESIZE":  3,
		"STEP_TYPE_VALIDATE":    4,
	}
)

func (x StepType) Enum() *StepType {
	p := new(StepType)
	*p = x
	return p
}

func (x StepType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (StepType) Descriptor() protoreflect.EnumDescriptor {
	return file_agent_proto_enumTypes[2].Descriptor()
}

func (StepType) Type() protoreflect.EnumType {
	return &file_agent_proto_enumTypes[2]
}

func (x StepType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use StepType.Descriptor instead.
func (StepType) EnumDescriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{2}
}

// ExecutionStatus for plan execution
type ExecutionStatus int32

const (
	ExecutionStatus_EXECUTION_STATUS_UNSPECIFIED ExecutionStatus = 0
	ExecutionStatus_EXECUTION_STATUS_PENDING     ExecutionStatus = 1
	ExecutionStatus_EXECUTION_STATUS_RUNNING     ExecutionStatus = 2
	ExecutionStatus_EXECUTION_STATUS_COMPLETED   ExecutionStatus = 3
	ExecutionStatus_EXECUTION_STATUS_FAILED      ExecutionStatus = 4
)

// Enum value maps for ExecutionStatus.
var (
	ExecutionStatus_name = map[int32]string{
		0: "EXECUTION_STATUS_UNSPECIFIED",
		1: "EXECUTION_STATUS_PENDING",
		2: "EXECUTION_STATUS_RUNNING",
		3: "EXECUTION_STATUS_COMPLETED",
		4: "EXECUTION_STATUS_FAILED",
	}
	ExecutionStatus_value = map[string]int32{
		"EXECUTION_STATUS_UNSPECIFIED": 0,
		"EXECUTION_STATUS_PENDING":     1,
		"EXECUTION_STATUS_RUNNING":     2,
		"EXECUTION_STATUS_COMPLETED":   3,
		"EXECUTION_STATUS_FAILED":      4,
	}
)

func (x ExecutionStatus) Enum() *ExecutionStatus {
	p := new(ExecutionStatus)
	*p = x
	return p
}

func (x ExecutionStatus) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ExecutionStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_agent_proto_enumTypes[3].Descriptor()
}

func (ExecutionStatus) Type() protoreflect.EnumType {
	return &file_agent_proto_enumTypes[3]
}

func (x ExecutionStatus) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ExecutionStatus.Descriptor instead.
func (ExecutionStatus) EnumDescriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{3}
}

// QueryRequest represents a user query
type QueryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The user's query text
	Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	// Session ID for conversation continuity
	SessionId string `protobuf:"bytes,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// User ID for personalization and audit
	UserId string `protobuf:"bytes,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// Conversation history for context
	ConversationHistory []*Message `protobuf:"bytes,4,rep,name=conversation_history,json=conversationHistory,proto3" json:"conversation_history,omitempty"`
	// Additional metadata
	Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Query configuration options
	Options       *QueryOptions `protobuf:"bytes,6,opt,name=options,proto3" json:"options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*QueryRequest) ProtoMessage() {}

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

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

func (x *QueryRequest) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

func (x *QueryRequest) GetUserId() string {
	if x != nil {
		return x.UserId
	}
	return ""
}

func (x *QueryRequest) GetConversationHistory() []*Message {
	if x != nil {
		return x.ConversationHistory
	}
	return nil
}

func (x *QueryRequest) GetMetadata() map[string]string {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *QueryRequest) GetOptions() *QueryOptions {
	if x != nil {
		return x.Options
	}
	return nil
}

// QueryOptions configures query processing behavior
type QueryOptions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Maximum number of sources to retrieve
	MaxSources int32 `protobuf:"varint,1,opt,name=max_sources,json=maxSources,proto3" json:"max_sources,omitempty"`
	// Enable/disable caching
	UseCache bool `protobuf:"varint,2,opt,name=use_cache,json=useCache,proto3" json:"use_cache,omitempty"`
	// Enable agentic multi-step reasoning
	EnableAgentic bool `protobuf:"varint,3,opt,name=enable_agentic,json=enableAgentic,proto3" json:"enable_agentic,omitempty"`
	// Specific knowledge bases to search
	KnowledgeBases []string `protobuf:"bytes,4,rep,name=knowledge_bases,json=knowledgeBases,proto3" json:"knowledge_bases,omitempty"`
	// Temperature for LLM generation (0.0 - 1.0)
	Temperature float32 `protobuf:"fixed32,5,opt,name=temperature,proto3" json:"temperature,omitempty"`
	// Maximum tokens for response
	MaxTokens     int32 `protobuf:"varint,6,opt,name=max_tokens,json=maxTokens,proto3" json:"max_tokens,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*QueryOptions) ProtoMessage() {}

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

func (x *QueryOptions) GetMaxSources() int32 {
	if x != nil {
		return x.MaxSources
	}
	return 0
}

func (x *QueryOptions) GetUseCache() bool {
	if x != nil {
		return x.UseCache
	}
	return false
}

func (x *QueryOptions) GetEnableAgentic() bool {
	if x != nil {
		return x.EnableAgentic
	}
	return false
}

func (x *QueryOptions) GetKnowledgeBases() []string {
	if x != nil {
		return x.KnowledgeBases
	}
	return nil
}

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

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

// QueryResponse contains the complete answer
type QueryResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The generated answer text
	Answer string `protobuf:"bytes,1,opt,name=answer,proto3" json:"answer,omitempty"`
	// Sources used to generate the answer
	Sources []*Source `protobuf:"bytes,2,rep,name=sources,proto3" json:"sources,omitempty"`
	// Confidence score (0.0 - 1.0)
	Confidence float32 `protobuf:"fixed32,3,opt,name=confidence,proto3" json:"confidence,omitempty"`
	// Query processing metadata
	Metadata *QueryMetadata `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Suggested follow-up questions
	FollowUpQuestions []string `protobuf:"bytes,5,rep,name=follow_up_questions,json=followUpQuestions,proto3" json:"follow_up_questions,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*QueryResponse) ProtoMessage() {}

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

func (x *QueryResponse) GetAnswer() string {
	if x != nil {
		return x.Answer
	}
	return ""
}

func (x *QueryResponse) GetSources() []*Source {
	if x != nil {
		return x.Sources
	}
	return nil
}

func (x *QueryResponse) GetConfidence() float32 {
	if x != nil {
		return x.Confidence
	}
	return 0
}

func (x *QueryResponse) GetMetadata() *QueryMetadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *QueryResponse) GetFollowUpQuestions() []string {
	if x != nil {
		return x.FollowUpQuestions
	}
	return nil
}

// QueryResponseChunk for streaming responses
type QueryResponseChunk struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Chunk type: THINKING, RETRIEVAL, GENERATION, COMPLETE
	Type ChunkType `protobuf:"varint,1,opt,name=type,proto3,enum=rag.v1.ChunkType" json:"type,omitempty"`
	// Text content of the chunk
	Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	// Sources (populated in RETRIEVAL chunks)
	Sources []*Source `protobuf:"bytes,3,rep,name=sources,proto3" json:"sources,omitempty"`
	// Is this the final chunk?
	IsFinal       bool `protobuf:"varint,4,opt,name=is_final,json=isFinal,proto3" json:"is_final,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*QueryResponseChunk) ProtoMessage() {}

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

func (x *QueryResponseChunk) GetType() ChunkType {
	if x != nil {
		return x.Type
	}
	return ChunkType_CHUNK_TYPE_UNSPECIFIED
}

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

func (x *QueryResponseChunk) GetSources() []*Source {
	if x != nil {
		return x.Sources
	}
	return nil
}

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

// Source represents a retrieved document chunk
type Source struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Unique identifier for the source
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Document title
	Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	// Relevant text content
	Content string `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
	// Source URL or path
	Url string `protobuf:"bytes,4,opt,name=url,proto3" json:"url,omitempty"`
	// Relevance score (0.0 - 1.0)
	Score float32 `protobuf:"fixed32,5,opt,name=score,proto3" json:"score,omitempty"`
	// Source metadata
	Metadata map[string]string `protobuf:"bytes,6,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Page number or section reference
	Location      string `protobuf:"bytes,7,opt,name=location,proto3" json:"location,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Source) ProtoMessage() {}

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

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

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

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

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

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

func (x *Source) GetMetadata() map[string]string {
	if x != nil {
		return x.Metadata
	}
	return nil
}

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

// Message represents a conversation turn
type Message struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Message role: USER, ASSISTANT, SYSTEM
	Role MessageRole `protobuf:"varint,1,opt,name=role,proto3,enum=rag.v1.MessageRole" json:"role,omitempty"`
	// Message content
	Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	// Timestamp
	Timestamp     int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Message) ProtoMessage() {}

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

func (x *Message) GetRole() MessageRole {
	if x != nil {
		return x.Role
	}
	return MessageRole_MESSAGE_ROLE_UNSPECIFIED
}

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

func (x *Message) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

// QueryMetadata contains processing information
type QueryMetadata struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Total processing time in milliseconds
	ProcessingTimeMs int64 `protobuf:"varint,1,opt,name=processing_time_ms,json=processingTimeMs,proto3" json:"processing_time_ms,omitempty"`
	// Number of chunks retrieved
	ChunksRetrieved int32 `protobuf:"varint,2,opt,name=chunks_retrieved,json=chunksRetrieved,proto3" json:"chunks_retrieved,omitempty"`
	// Tokens used for generation
	TokensUsed int32 `protobuf:"varint,3,opt,name=tokens_used,json=tokensUsed,proto3" json:"tokens_used,omitempty"`
	// Whether result was cached
	CacheHit bool `protobuf:"varint,4,opt,name=cache_hit,json=cacheHit,proto3" json:"cache_hit,omitempty"`
	// Query routing decision
	RoutingStrategy string `protobuf:"bytes,5,opt,name=routing_strategy,json=routingStrategy,proto3" json:"routing_strategy,omitempty"`
	// Trace ID for debugging
	TraceId       string `protobuf:"bytes,6,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*QueryMetadata) ProtoMessage() {}

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

func (x *QueryMetadata) GetProcessingTimeMs() int64 {
	if x != nil {
		return x.ProcessingTimeMs
	}
	return 0
}

func (x *QueryMetadata) GetChunksRetrieved() int32 {
	if x != nil {
		return x.ChunksRetrieved
	}
	return 0
}

func (x *QueryMetadata) GetTokensUsed() int32 {
	if x != nil {
		return x.TokensUsed
	}
	return 0
}

func (x *QueryMetadata) GetCacheHit() bool {
	if x != nil {
		return x.CacheHit
	}
	return false
}

func (x *QueryMetadata) GetRoutingStrategy() string {
	if x != nil {
		return x.RoutingStrategy
	}
	return ""
}

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

// CreateAgentRequest for creating specialized agents
type CreateAgentRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Agent name
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Agent description
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// System prompt for the agent
	SystemPrompt string `protobuf:"bytes,3,opt,name=system_prompt,json=systemPrompt,proto3" json:"system_prompt,omitempty"`
	// Tools available to the agent
	Tools []string `protobuf:"bytes,4,rep,name=tools,proto3" json:"tools,omitempty"`
	// Agent configuration
	Config        *AgentConfig `protobuf:"bytes,5,opt,name=config,proto3" json:"config,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateAgentRequest) ProtoMessage() {}

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

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

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

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

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

func (x *CreateAgentRequest) GetConfig() *AgentConfig {
	if x != nil {
		return x.Config
	}
	return nil
}

// Agent represents a configured AI agent
type Agent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Unique agent ID
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Agent name
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Agent description
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Creation timestamp
	CreatedAt int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Agent configuration
	Config        *AgentConfig `protobuf:"bytes,5,opt,name=config,proto3" json:"config,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Agent) ProtoMessage() {}

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

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

func (x *Agent) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Agent) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *Agent) GetCreatedAt() int64 {
	if x != nil {
		return x.CreatedAt
	}
	return 0
}

func (x *Agent) GetConfig() *AgentConfig {
	if x != nil {
		return x.Config
	}
	return nil
}

// AgentConfig contains agent settings
type AgentConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// LLM model to use
	Model string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
	// Temperature setting
	Temperature float32 `protobuf:"fixed32,2,opt,name=temperature,proto3" json:"temperature,omitempty"`
	// Maximum iterations for agentic loops
	MaxIterations int32 `protobuf:"varint,3,opt,name=max_iterations,json=maxIterations,proto3" json:"max_iterations,omitempty"`
	// Timeout in seconds
	TimeoutSeconds int32 `protobuf:"varint,4,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*AgentConfig) ProtoMessage() {}

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

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

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

func (x *AgentConfig) GetMaxIterations() int32 {
	if x != nil {
		return x.MaxIterations
	}
	return 0
}

func (x *AgentConfig) GetTimeoutSeconds() int32 {
	if x != nil {
		return x.TimeoutSeconds
	}
	return 0
}

// ExecutionPlan for multi-step queries
type ExecutionPlan struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Plan ID
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Original query
	Query string `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"`
	// Execution steps
	Steps         []*ExecutionStep `protobuf:"bytes,3,rep,name=steps,proto3" json:"steps,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExecutionPlan) ProtoMessage() {}

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

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

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

func (x *ExecutionPlan) GetSteps() []*ExecutionStep {
	if x != nil {
		return x.Steps
	}
	return nil
}

// ExecutionStep represents a single step in the plan
type ExecutionStep struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Step ID
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Step type: SEARCH, ANALYZE, SYNTHESIZE
	Type StepType `protobuf:"varint,2,opt,name=type,proto3,enum=rag.v1.StepType" json:"type,omitempty"`
	// Step description
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Tool to use
	Tool string `protobuf:"bytes,4,opt,name=tool,proto3" json:"tool,omitempty"`
	// Input for the step
	Input string `protobuf:"bytes,5,opt,name=input,proto3" json:"input,omitempty"`
	// Dependencies (IDs of steps that must complete first)
	Dependencies  []string `protobuf:"bytes,6,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExecutionStep) ProtoMessage() {}

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

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

func (x *ExecutionStep) GetType() StepType {
	if x != nil {
		return x.Type
	}
	return StepType_STEP_TYPE_UNSPECIFIED
}

func (x *ExecutionStep) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *ExecutionStep) GetTool() string {
	if x != nil {
		return x.Tool
	}
	return ""
}

func (x *ExecutionStep) GetInput() string {
	if x != nil {
		return x.Input
	}
	return ""
}

func (x *ExecutionStep) GetDependencies() []string {
	if x != nil {
		return x.Dependencies
	}
	return nil
}

// PlanResult contains execution results
type PlanResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Plan ID
	PlanId string `protobuf:"bytes,1,opt,name=plan_id,json=planId,proto3" json:"plan_id,omitempty"`
	// Execution status
	Status ExecutionStatus `protobuf:"varint,2,opt,name=status,proto3,enum=rag.v1.ExecutionStatus" json:"status,omitempty"`
	// Step results
	StepResults []*StepResult `protobuf:"bytes,3,rep,name=step_results,json=stepResults,proto3" json:"step_results,omitempty"`
	// Final answer
	FinalAnswer string `protobuf:"bytes,4,opt,name=final_answer,json=finalAnswer,proto3" json:"final_answer,omitempty"`
	// Total execution time
	ExecutionTimeMs int64 `protobuf:"varint,5,opt,name=execution_time_ms,json=executionTimeMs,proto3" json:"execution_time_ms,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*PlanResult) ProtoMessage() {}

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

func (x *PlanResult) GetPlanId() string {
	if x != nil {
		return x.PlanId
	}
	return ""
}

func (x *PlanResult) GetStatus() ExecutionStatus {
	if x != nil {
		return x.Status
	}
	return ExecutionStatus_EXECUTION_STATUS_UNSPECIFIED
}

func (x *PlanResult) GetStepResults() []*StepResult {
	if x != nil {
		return x.StepResults
	}
	return nil
}

func (x *PlanResult) GetFinalAnswer() string {
	if x != nil {
		return x.FinalAnswer
	}
	return ""
}

func (x *PlanResult) GetExecutionTimeMs() int64 {
	if x != nil {
		return x.ExecutionTimeMs
	}
	return 0
}

// StepResult contains individual step results
type StepResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Step ID
	StepId string `protobuf:"bytes,1,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
	// Step status
	Status ExecutionStatus `protobuf:"varint,2,opt,name=status,proto3,enum=rag.v1.ExecutionStatus" json:"status,omitempty"`
	// Step output
	Output string `protobuf:"bytes,3,opt,name=output,proto3" json:"output,omitempty"`
	// Error message if failed
	Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
	// Execution time
	ExecutionTimeMs int64 `protobuf:"varint,5,opt,name=execution_time_ms,json=executionTimeMs,proto3" json:"execution_time_ms,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*StepResult) ProtoMessage() {}

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

func (x *StepResult) GetStepId() string {
	if x != nil {
		return x.StepId
	}
	return ""
}

func (x *StepResult) GetStatus() ExecutionStatus {
	if x != nil {
		return x.Status
	}
	return ExecutionStatus_EXECUTION_STATUS_UNSPECIFIED
}

func (x *StepResult) GetOutput() string {
	if x != nil {
		return x.Output
	}
	return ""
}

func (x *StepResult) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

func (x *StepResult) GetExecutionTimeMs() int64 {
	if x != nil {
		return x.ExecutionTimeMs
	}
	return 0
}

// QueryStatusRequest to check query progress
type QueryStatusRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Query ID
	QueryId       string `protobuf:"bytes,1,opt,name=query_id,json=queryId,proto3" json:"query_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*QueryStatusRequest) ProtoMessage() {}

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

func (x *QueryStatusRequest) GetQueryId() string {
	if x != nil {
		return x.QueryId
	}
	return ""
}

// QueryStatus represents current query state
type QueryStatus struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Query ID
	QueryId string `protobuf:"bytes,1,opt,name=query_id,json=queryId,proto3" json:"query_id,omitempty"`
	// Current status
	Status ExecutionStatus `protobuf:"varint,2,opt,name=status,proto3,enum=rag.v1.ExecutionStatus" json:"status,omitempty"`
	// Progress percentage (0-100)
	Progress int32 `protobuf:"varint,3,opt,name=progress,proto3" json:"progress,omitempty"`
	// Current step description
	CurrentStep   string `protobuf:"bytes,4,opt,name=current_step,json=currentStep,proto3" json:"current_step,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*QueryStatus) ProtoMessage() {}

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

func (x *QueryStatus) GetQueryId() string {
	if x != nil {
		return x.QueryId
	}
	return ""
}

func (x *QueryStatus) GetStatus() ExecutionStatus {
	if x != nil {
		return x.Status
	}
	return ExecutionStatus_EXECUTION_STATUS_UNSPECIFIED
}

func (x *QueryStatus) GetProgress() int32 {
	if x != nil {
		return x.Progress
	}
	return 0
}

func (x *QueryStatus) GetCurrentStep() string {
	if x != nil {
		return x.CurrentStep
	}
	return ""
}

// SecurityContext for request authentication/authorization
type SecurityContext struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// User ID
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// User roles
	Roles []string `protobuf:"bytes,2,rep,name=roles,proto3" json:"roles,omitempty"`
	// Tenant ID for multi-tenancy
	TenantId string `protobuf:"bytes,3,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	// Additional claims
	Claims        map[string]string `protobuf:"bytes,4,rep,name=claims,proto3" json:"claims,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SecurityContext) ProtoMessage() {}

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

func (x *SecurityContext) GetUserId() string {
	if x != nil {
		return x.UserId
	}
	return ""
}

func (x *SecurityContext) GetRoles() []string {
	if x != nil {
		return x.Roles
	}
	return nil
}

func (x *SecurityContext) GetTenantId() string {
	if x != nil {
		return x.TenantId
	}
	return ""
}

func (x *SecurityContext) GetClaims() map[string]string {
	if x != nil {
		return x.Claims
	}
	return nil
}

var File_agent_proto protoreflect.FileDescriptor

const file_agent_proto_rawDesc = "" +
	"\n" +
	"\vagent.proto\x12\x06rag.v1\"\xcd\x02\n" +
	"\fQueryRequest\x12\x14\n" +
	"\x05query\x18\x01 \x01(\tR\x05query\x12\x1d\n" +
	"\n" +
	"session_id\x18\x02 \x01(\tR\tsessionId\x12\x17\n" +
	"\auser_id\x18\x03 \x01(\tR\x06userId\x12B\n" +
	"\x14conversation_history\x18\x04 \x03(\v2\x0f.rag.v1.MessageR\x13conversationHistory\x12>\n" +
	"\bmetadata\x18\x05 \x03(\v2\".rag.v1.QueryRequest.MetadataEntryR\bmetadata\x12.\n" +
	"\aoptions\x18\x06 \x01(\v2\x14.rag.v1.QueryOptionsR\aoptions\x1a;\n" +
	"\rMetadataEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xdd\x01\n" +
	"\fQueryOptions\x12\x1f\n" +
	"\vmax_sources\x18\x01 \x01(\x05R\n" +
	"maxSources\x12\x1b\n" +
	"\tuse_cache\x18\x02 \x01(\bR\buseCache\x12%\n" +
	"\x0eenable_agentic\x18\x03 \x01(\bR\renableAgentic\x12'\n" +
	"\x0fknowledge_bases\x18\x04 \x03(\tR\x0eknowledgeBases\x12 \n" +
	"\vtemperature\x18\x05 \x01(\x02R\vtemperature\x12\x1d\n" +
	"\n" +
	"max_tokens\x18\x06 \x01(\x05R\tmaxTokens\"\xd4\x01\n" +
	"\rQueryResponse\x12\x16\n" +
	"\x06answer\x18\x01 \x01(\tR\x06answer\x12(\n" +
	"\asources\x18\x02 \x03(\v2\x0e.rag.v1.SourceR\asources\x12\x1e\n" +
	"\n" +
	"confidence\x18\x03 \x01(\x02R\n" +
	"confidence\x121\n" +
	"\bmetadata\x18\x04 \x01(\v2\x15.rag.v1.QueryMetadataR\bmetadata\x12.\n" +
	"\x13follow_up_questions\x18\x05 \x03(\tR\x11followUpQuestions\"\x9a\x01\n" +
	"\x12QueryResponseChunk\x12%\n" +
	"\x04type\x18\x01 \x01(\x0e2\x11.rag.v1.ChunkTypeR\x04type\x12\x18\n" +
	"\acontent\x18\x02 \x01(\tR\acontent\x12(\n" +
	"\asources\x18\x03 \x03(\v2\x0e.rag.v1.SourceR\asources\x12\x19\n" +
	"\bis_final\x18\x04 \x01(\bR\aisFinal\"\x83\x02\n" +
	"\x06Source\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +
	"\x05title\x18\x02 \x01(\tR\x05title\x12\x18\n" +
	"\acontent\x18\x03 \x01(\tR\acontent\x12\x10\n" +
	"\x03url\x18\x04 \x01(\tR\x03url\x12\x14\n" +
	"\x05score\x18\x05 \x01(\x02R\x05score\x128\n" +
	"\bmetadata\x18\x06 \x03(\v2\x1c.rag.v1.Source.MetadataEntryR\bmetadata\x12\x1a\n" +
	"\blocation\x18\a \x01(\tR\blocation\x1a;\n" +
	"\rMetadataEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"j\n" +
	"\aMessage\x12'\n" +
	"\x04role\x18\x01 \x01(\x0e2\x13.rag.v1.MessageRoleR\x04role\x12\x18\n" +
	"\acontent\x18\x02 \x01(\tR\acontent\x12\x1c\n" +
	"\ttimestamp\x18\x03 \x01(\x03R\ttimestamp\"\xec\x01\n" +
	"\rQueryMetadata\x12,\n" +
	"\x12processing_time_ms\x18\x01 \x01(\x03R\x10processingTimeMs\x12)\n" +
	"\x10chunks_retrieved\x18\x02 \x01(\x05R\x0fchunksRetrieved\x12\x1f\n" +
	"\vtokens_used\x18\x03 \x01(\x05R\n" +
	"tokensUsed\x12\x1b\n" +
	"\tcache_hit\x18\x04 \x01(\bR\bcacheHit\x12)\n" +
	"\x10routing_strategy\x18\x05 \x01(\tR\x0froutingStrategy\x12\x19\n" +
	"\btrace_id\x18\x06 \x01(\tR\atraceId\"\xb2\x01\n" +
	"\x12CreateAgentRequest\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12 \n" +
	"\vdescription\x18\x02 \x01(\tR\vdescription\x12#\n" +
	"\rsystem_prompt\x18\x03 \x01(\tR\fsystemPrompt\x12\x14\n" +
	"\x05tools\x18\x04 \x03(\tR\x05tools\x12+\n" +
	"\x06config\x18\x05 \x01(\v2\x13.rag.v1.AgentConfigR\x06config\"\x99\x01\n" +
	"\x05Agent\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12 \n" +
	"\vdescription\x18\x03 \x01(\tR\vdescription\x12\x1d\n" +
	"\n" +
	"created_at\x18\x04 \x01(\x03R\tcreatedAt\x12+\n" +
	"\x06config\x18\x05 \x01(\v2\x13.rag.v1.AgentConfigR\x06config\"\x95\x01\n" +
	"\vAgentConfig\x12\x14\n" +
	"\x05model\x18\x01 \x01(\tR\x05model\x12 \n" +
	"\vtemperature\x18\x02 \x01(\x02R\vtemperature\x12%\n" +
	"\x0emax_iterations\x18\x03 \x01(\x05R\rmaxIterations\x12'\n" +
	"\x0ftimeout_seconds\x18\x04 \x01(\x05R\x0etimeoutSeconds\"b\n" +
	"\rExecutionPlan\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +
	"\x05query\x18\x02 \x01(\tR\x05query\x12+\n" +
	"\x05steps\x18\x03 \x03(\v2\x15.rag.v1.ExecutionStepR\x05steps\"\xb5\x01\n" +
	"\rExecutionStep\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12$\n" +
	"\x04type\x18\x02 \x01(\x0e2\x10.rag.v1.StepTypeR\x04type\x12 \n" +
	"\vdescription\x18\x03 \x01(\tR\vdescription\x12\x12\n" +
	"\x04tool\x18\x04 \x01(\tR\x04tool\x12\x14\n" +
	"\x05input\x18\x05 \x01(\tR\x05input\x12\"\n" +
	"\fdependencies\x18\x06 \x03(\tR\fdependencies\"\xdc\x01\n" +
	"\n" +
	"PlanResult\x12\x17\n" +
	"\aplan_id\x18\x01 \x01(\tR\x06planId\x12/\n" +
	"\x06status\x18\x02 \x01(\x0e2\x17.rag.v1.ExecutionStatusR\x06status\x125\n" +
	"\fstep_results\x18\x03 \x03(\v2\x12.rag.v1.StepResultR\vstepResults\x12!\n" +
	"\ffinal_answer\x18\x04 \x01(\tR\vfinalAnswer\x12*\n" +
	"\x11execution_time_ms\x18\x05 \x01(\x03R\x0fexecutionTimeMs\"\xb0\x01\n" +
	"\n" +
	"StepResult\x12\x17\n" +
	"\astep_id\x18\x01 \x01(\tR\x06stepId\x12/\n" +
	"\x06status\x18\x02 \x01(\x0e2\x17.rag.v1.ExecutionStatusR\x06status\x12\x16\n" +
	"\x06output\x18\x03 \x01(\tR\x06output\x12\x14\n" +
	"\x05error\x18\x04 \x01(\tR\x05error\x12*\n" +
	"\x11execution_time_ms\x18\x05 \x01(\x03R\x0fexecutionTimeMs\"/\n" +
	"\x12QueryStatusRequest\x12\x19\n" +
	"\bquery_id\x18\x01 \x01(\tR\aqueryId\"\x98\x01\n" +
	"\vQueryStatus\x12\x19\n" +
	"\bquery_id\x18\x01 \x01(\tR\aqueryId\x12/\n" +
	"\x06status\x18\x02 \x01(\x0e2\x17.rag.v1.ExecutionStatusR\x06status\x12\x1a\n" +
	"\bprogress\x18\x03 \x01(\x05R\bprogress\x12!\n" +
	"\fcurrent_step\x18\x04 \x01(\tR\vcurrentStep\"\xd5\x01\n" +
	"\x0fSecurityContext\x12\x17\n" +
	"\auser_id\x18\x01 \x01(\tR\x06userId\x12\x14\n" +
	"\x05roles\x18\x02 \x03(\tR\x05roles\x12\x1b\n" +
	"\ttenant_id\x18\x03 \x01(\tR\btenantId\x12;\n" +
	"\x06claims\x18\x04 \x03(\v2#.rag.v1.SecurityContext.ClaimsEntryR\x06claims\x1a9\n" +
	"\vClaimsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01*\xa4\x01\n" +
	"\tChunkType\x12\x1a\n" +
	"\x16CHUNK_TYPE_UNSPECIFIED\x10\x00\x12\x17\n" +
	"\x13CHUNK_TYPE_THINKING\x10\x01\x12\x18\n" +
	"\x14CHUNK_TYPE_RETRIEVAL\x10\x02\x12\x19\n" +
	"\x15CHUNK_TYPE_GENERATION\x10\x03\x12\x17\n" +
	"\x13CHUNK_TYPE_COMPLETE\x10\x04\x12\x14\n" +
	"\x10CHUNK_TYPE_ERROR\x10\x05*w\n" +
	"\vMessageRole\x12\x1c\n" +
	"\x18MESSAGE_ROLE_UNSPECIFIED\x10\x00\x12\x15\n" +
	"\x11MESSAGE_ROLE_USER\x10\x01\x12\x1a\n" +
	"\x16MESSAGE_ROLE_ASSISTANT\x10\x02\x12\x17\n" +
	"\x13MESSAGE_ROLE_SYSTEM\x10\x03*\x84\x01\n" +
	"\bStepType\x12\x19\n" +
	"\x15STEP_TYPE_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10STEP_TYPE_SEARCH\x10\x01\x12\x15\n" +
	"\x11STEP_TYPE_ANALYZE\x10\x02\x12\x18\n" +
	"\x14STEP_TYPE_SYNTHESIZE\x10\x03\x12\x16\n" +
	"\x12STEP_TYPE_VALIDATE\x10\x04*\xac\x01\n" +
	"\x0fExecutionStatus\x12 \n" +
	"\x1cEXECUTION_STATUS_UNSPECIFIED\x10\x00\x12\x1c\n" +
	"\x18EXECUTION_STATUS_PENDING\x10\x01\x12\x1c\n" +
	"\x18EXECUTION_STATUS_RUNNING\x10\x02\x12\x1e\n" +
	"\x1aEXECUTION_STATUS_COMPLETED\x10\x03\x12\x1b\n" +
	"\x17EXECUTION_STATUS_FAILED\x10\x042\xcc\x02\n" +
	"\fAgentService\x12;\n" +
	"\fProcessQuery\x12\x14.rag.v1.QueryRequest\x1a\x15.rag.v1.QueryResponse\x12H\n" +
	"\x12ProcessQueryStream\x12\x14.rag.v1.QueryRequest\x1a\x1a.rag.v1.QueryResponseChunk0\x01\x128\n" +
	"\vCreateAgent\x12\x1a.rag.v1.CreateAgentRequest\x1a\r.rag.v1.Agent\x128\n" +
	"\vExecutePlan\x12\x15.rag.v1.ExecutionPlan\x1a\x12.rag.v1.PlanResult\x12A\n" +
	"\x0eGetQueryStatus\x12\x1a.rag.v1.QueryStatusRequest\x1a\x13.rag.v1.QueryStatusB6Z4github.com/AmaniQuery/amaniquery/pkg/proto/gen/ragv1b\x06proto3"

var (
	file_agent_proto_rawDescOnce sync.Once
	file_agent_proto_rawDescData []byte
)

func file_agent_proto_rawDescGZIP() []byte {
	file_agent_proto_rawDescOnce.Do(func() {
		file_agent_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agent_proto_rawDesc), len(file_agent_proto_rawDesc)))
	})
	return file_agent_proto_rawDescData
}

var file_agent_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_agent_proto_goTypes = []any{
	(ChunkType)(0),             // 0: rag.v1.ChunkType
	(MessageRole)(0),           // 1: rag.v1.MessageRole
	(StepType)(0),              // 2: rag.v1.StepType
	(ExecutionStatus)(0),       // 3: rag.v1.ExecutionStatus
	(*QueryRequest)(nil),       // 4: rag.v1.QueryRequest
	(*QueryOptions)(nil),       // 5: rag.v1.QueryOptions
	(*QueryResponse)(nil),      // 6: rag.v1.QueryResponse
	(*QueryResponseChunk)(nil), // 7: rag.v1.QueryResponseChunk
	(*Source)(nil),             // 8: rag.v1.Source
	(*Message)(nil),            // 9: rag.v1.Message
	(*QueryMetadata)(nil),      // 10: rag.v1.QueryMetadata
	(*CreateAgentRequest)(nil), // 11: rag.v1.CreateAgentRequest
	(*Agent)(nil),              // 12: rag.v1.Agent
	(*AgentConfig)(nil),        // 13: rag.v1.AgentConfig
	(*ExecutionPlan)(nil),      // 14: rag.v1.ExecutionPlan
	(*ExecutionStep)(nil),      // 15: rag.v1.ExecutionStep
	(*PlanResult)(nil),         // 16: rag.v1.PlanResult
	(*StepResult)(nil),         // 17: rag.v1.StepResult
	(*QueryStatusRequest)(nil), // 18: rag.v1.QueryStatusRequest
	(*QueryStatus)(nil),        // 19: rag.v1.QueryStatus
	(*SecurityContext)(nil),    // 20: rag.v1.SecurityContext
	nil,                        // 21: rag.v1.QueryRequest.MetadataEntry
	nil,                        // 22: rag.v1.Source.MetadataEntry
	nil,                        // 23: rag.v1.SecurityContext.ClaimsEntry
}
var file_agent_proto_depIdxs = []int32{
	9,  // 0: rag.v1.QueryRequest.conversation_history:type_name -> rag.v1.Message
	21, // 1: rag.v1.QueryRequest.metadata:type_name -> rag.v1.QueryRequest.MetadataEntry
	5,  // 2: rag.v1.QueryRequest.options:type_name -> rag.v1.QueryOptions
	8,  // 3: rag.v1.QueryResponse.sources:type_name -> rag.v1.Source
	10, // 4: rag.v1.QueryResponse.metadata:type_name -> rag.v1.QueryMetadata
	0,  // 5: rag.v1.QueryResponseChunk.type:type_name -> rag.v1.ChunkType
	8,  // 6: rag.v1.QueryResponseChunk.sources:type_name -> rag.v1.Source
	22, // 7: rag.v1.Source.metadata:type_name -> rag.v1.Source.MetadataEntry
	1,  // 8: rag.v1.Message.role:type_name -> rag.v1.MessageRole
	13, // 9: rag.v1.CreateAgentRequest.config:type_name -> rag.v1.AgentConfig
	13, // 10: rag.v1.Agent.config:type_name -> rag.v1.AgentConfig
	15, // 11: rag.v1.ExecutionPlan.steps:type_name -> rag.v1.ExecutionStep
	2,  // 12: rag.v1.ExecutionStep.type:type_name -> rag.v1.StepType
	3,  // 13: rag.v1.PlanResult.status:type_name -> rag.v1.ExecutionStatus
	17, // 14: rag.v1.PlanResult.step_results:type_name -> rag.v1.StepResult
	3,  // 15: rag.v1.StepResult.status:type_name -> rag.v1.ExecutionStatus
	3,  // 16: rag.v1.QueryStatus.status:type_name -> rag.v1.ExecutionStatus
	23, // 17: rag.v1.SecurityContext.claims:type_name -> rag.v1.SecurityContext.ClaimsEntry
	4,  // 18: rag.v1.AgentService.ProcessQuery:input_type -> rag.v1.QueryRequest
	4,  // 19: rag.v1.AgentService.ProcessQueryStream:input_type -> rag.v1.QueryRequest
	11, // 20: rag.v1.AgentService.CreateAgent:input_type -> rag.v1.CreateAgentRequest
	14, // 21: rag.v1.AgentService.ExecutePlan:input_type -> rag.v1.ExecutionPlan
	18, // 22: rag.v1.AgentService.GetQueryStatus:input_type -> rag.v1.QueryStatusRequest
	6,  // 23: rag.v1.AgentService.ProcessQuery:output_type -> rag.v1.QueryResponse
	7,  // 24: rag.v1.AgentService.ProcessQueryStream:output_type -> rag.v1.QueryResponseChunk
	12, // 25: rag.v1.AgentService.CreateAgent:output_type -> rag.v1.Agent
	16, // 26: rag.v1.AgentService.ExecutePlan:output_type -> rag.v1.PlanResult
	19, // 27: rag.v1.AgentService.GetQueryStatus:output_type -> rag.v1.QueryStatus
	23, // [23:28] is the sub-list for method output_type
	18, // [18:23] is the sub-list for method input_type
	18, // [18:18] is the sub-list for extension type_name
	18, // [18:18] is the sub-list for extension extendee
	0,  // [0:18] is the sub-list for field type_name
}

func init() { file_agent_proto_init() }
func file_agent_proto_init() {
	if File_agent_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agent_proto_rawDesc), len(file_agent_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   20,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_agent_proto_goTypes,
		DependencyIndexes: file_agent_proto_depIdxs,
		EnumInfos:         file_agent_proto_enumTypes,
		MessageInfos:      file_agent_proto_msgTypes,
	}.Build()
	File_agent_proto = out.File
	file_agent_proto_goTypes = nil
	file_agent_proto_depIdxs = nil
}