livekit-protocol 0.8.2

// Copyright 2026 LiveKit, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// AgentThread: the durable conversation between an agent and a person, across
// channels and over time. Identified by an "AT_" id. Holds a scope, attributes,
// an idle TTL and the AgentDB database created with it. Served by
// cloud-protocol's AgentThreads. The conversation inside follows thread_schema_v1.sql, shared
// by the agents framework, which writes it, and the platform, which reads it.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        v7.35.1
// source: agent/livekit_agent_thread.proto

package agent

import (
	_ "github.com/livekit/protocol/livekit/logger"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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

// Direction of a listing. Each request documents what unset means.
type AgentThread_SortOrder int32

const (
	AgentThread_SORT_ORDER_UNSPECIFIED AgentThread_SortOrder = 0
	AgentThread_SORT_ORDER_ASC         AgentThread_SortOrder = 1
	AgentThread_SORT_ORDER_DESC        AgentThread_SortOrder = 2
)

// Enum value maps for AgentThread_SortOrder.
var (
	AgentThread_SortOrder_name = map[int32]string{
		0: "SORT_ORDER_UNSPECIFIED",
		1: "SORT_ORDER_ASC",
		2: "SORT_ORDER_DESC",
	}
	AgentThread_SortOrder_value = map[string]int32{
		"SORT_ORDER_UNSPECIFIED": 0,
		"SORT_ORDER_ASC":         1,
		"SORT_ORDER_DESC":        2,
	}
)

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

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

func (AgentThread_SortOrder) Descriptor() protoreflect.EnumDescriptor {
	return file_agent_livekit_agent_thread_proto_enumTypes[0].Descriptor()
}

func (AgentThread_SortOrder) Type() protoreflect.EnumType {
	return &file_agent_livekit_agent_thread_proto_enumTypes[0]
}

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

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

// A task is never UNSPECIFIED.
type AgentTask_Status int32

const (
	AgentTask_UNSPECIFIED AgentTask_Status = 0
	AgentTask_RUNNING     AgentTask_Status = 1
	AgentTask_COMPLETED   AgentTask_Status = 2
	AgentTask_FAILED      AgentTask_Status = 3
	AgentTask_CANCELED    AgentTask_Status = 4
)

// Enum value maps for AgentTask_Status.
var (
	AgentTask_Status_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "RUNNING",
		2: "COMPLETED",
		3: "FAILED",
		4: "CANCELED",
	}
	AgentTask_Status_value = map[string]int32{
		"UNSPECIFIED": 0,
		"RUNNING":     1,
		"COMPLETED":   2,
		"FAILED":      3,
		"CANCELED":    4,
	}
)

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

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

func (AgentTask_Status) Descriptor() protoreflect.EnumDescriptor {
	return file_agent_livekit_agent_thread_proto_enumTypes[1].Descriptor()
}

func (AgentTask_Status) Type() protoreflect.EnumType {
	return &file_agent_livekit_agent_thread_proto_enumTypes[1]
}

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

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

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

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

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

func (*AgentThread) ProtoMessage() {}

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

// AgentTask: background work an agent runs within a thread, such as a booking
// that takes minutes.
type AgentTask struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentTask) ProtoMessage() {}

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

type AgentThread_CreateRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Groups threads, e.g. by user: an application-defined value, typically the
	// user's identity. An AgentThreadGrant is scoped by it.
	Scope      string            `protobuf:"bytes,1,opt,name=scope,proto3" json:"scope,omitempty"`
	Attributes map[string]string `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Unset takes the server default.
	IdleTtl       *durationpb.Duration `protobuf:"bytes,3,opt,name=idle_ttl,json=idleTtl,proto3" json:"idle_ttl,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_CreateRequest) ProtoMessage() {}

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

func (x *AgentThread_CreateRequest) GetScope() string {
	if x != nil {
		return x.Scope
	}
	return ""
}

func (x *AgentThread_CreateRequest) GetAttributes() map[string]string {
	if x != nil {
		return x.Attributes
	}
	return nil
}

func (x *AgentThread_CreateRequest) GetIdleTtl() *durationpb.Duration {
	if x != nil {
		return x.IdleTtl
	}
	return nil
}

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

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

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

func (*AgentThread_GetRequest) ProtoMessage() {}

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

func (x *AgentThread_GetRequest) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

// The threads of one scope, newest first.
type AgentThread_ListRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Scope string                 `protobuf:"bytes,1,opt,name=scope,proto3" json:"scope,omitempty"`
	// next_page_token of the previous ListResponse; empty for the first page.
	PageToken     string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	Limit         int32  `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_ListRequest) ProtoMessage() {}

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

func (x *AgentThread_ListRequest) GetScope() string {
	if x != nil {
		return x.Scope
	}
	return ""
}

func (x *AgentThread_ListRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

func (x *AgentThread_ListRequest) GetLimit() int32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

type AgentThread_ListResponse struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Threads []*AgentThread_Thread  `protobuf:"bytes,1,rep,name=threads,proto3" json:"threads,omitempty"`
	// Empty when exhausted.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_ListResponse) ProtoMessage() {}

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

func (x *AgentThread_ListResponse) GetThreads() []*AgentThread_Thread {
	if x != nil {
		return x.Threads
	}
	return nil
}

func (x *AgentThread_ListResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

type AgentThread_UpdateRequest struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	ThreadId string                 `protobuf:"bytes,1,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"`
	// Added to the existing attributes; an empty value deletes the entry.
	Attributes    map[string]string    `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	IdleTtl       *durationpb.Duration `protobuf:"bytes,3,opt,name=idle_ttl,json=idleTtl,proto3" json:"idle_ttl,omitempty"` // Every update counts as activity and pushes expires_at out by idle_ttl.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_UpdateRequest) ProtoMessage() {}

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

func (x *AgentThread_UpdateRequest) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

func (x *AgentThread_UpdateRequest) GetAttributes() map[string]string {
	if x != nil {
		return x.Attributes
	}
	return nil
}

func (x *AgentThread_UpdateRequest) GetIdleTtl() *durationpb.Duration {
	if x != nil {
		return x.IdleTtl
	}
	return nil
}

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

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

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

func (*AgentThread_DeleteRequest) ProtoMessage() {}

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

func (x *AgentThread_DeleteRequest) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

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

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

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

func (*AgentThread_DeleteResponse) ProtoMessage() {}

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

// The thread's chat items, oldest first unless sort_order says otherwise.
type AgentThread_GetItemsRequest struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	ThreadId string                 `protobuf:"bytes,1,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"`
	// One agent's items; empty for every agent's.
	Agent string `protobuf:"bytes,2,opt,name=agent,proto3" json:"agent,omitempty"`
	// next_page_token of the previous GetItemsResponse; empty for the first page.
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	Limit     int32  `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	// Unset or ASC is oldest first. DESC starts from the latest item and each
	// next_page_token walks back through older ones.
	SortOrder     AgentThread_SortOrder `protobuf:"varint,5,opt,name=sort_order,json=sortOrder,proto3,enum=livekit.agent.AgentThread_SortOrder" json:"sort_order,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_GetItemsRequest) ProtoMessage() {}

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

func (x *AgentThread_GetItemsRequest) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

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

func (x *AgentThread_GetItemsRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

func (x *AgentThread_GetItemsRequest) GetLimit() int32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

func (x *AgentThread_GetItemsRequest) GetSortOrder() AgentThread_SortOrder {
	if x != nil {
		return x.SortOrder
	}
	return AgentThread_SORT_ORDER_UNSPECIFIED
}

type AgentThread_GetItemsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Items []*AgentThread_Item    `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	// Empty when exhausted.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_GetItemsResponse) ProtoMessage() {}

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

func (x *AgentThread_GetItemsResponse) GetItems() []*AgentThread_Item {
	if x != nil {
		return x.Items
	}
	return nil
}

func (x *AgentThread_GetItemsResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

// One chat item of an agent. Stored as the JSON of
// ChatContext.ChatItem (items.payload in thread_schema_v1.sql).
type AgentThread_Item struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Agent string                 `protobuf:"bytes,1,opt,name=agent,proto3" json:"agent,omitempty"`
	// Position in the agent's history.
	Seq int64 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`
	// The A2A message the item came from.
	MessageId     string                `protobuf:"bytes,3,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	Item          *ChatContext_ChatItem `protobuf:"bytes,4,opt,name=item,proto3" json:"item,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_Item) ProtoMessage() {}

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

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

func (x *AgentThread_Item) GetSeq() int64 {
	if x != nil {
		return x.Seq
	}
	return 0
}

func (x *AgentThread_Item) GetMessageId() string {
	if x != nil {
		return x.MessageId
	}
	return ""
}

func (x *AgentThread_Item) GetItem() *ChatContext_ChatItem {
	if x != nil {
		return x.Item
	}
	return nil
}

type AgentThread_Thread struct {
	state      protoimpl.MessageState `protogen:"open.v1"`
	ThreadId   string                 `protobuf:"bytes,1,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"`
	Scope      string                 `protobuf:"bytes,2,opt,name=scope,proto3" json:"scope,omitempty"`
	Attributes map[string]string      `protobuf:"bytes,3,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	CreatedAt  *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	LastActive *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=last_active,json=lastActive,proto3" json:"last_active,omitempty"`
	// last_active + idle_ttl; every update pushes it out. The thread and its
	// database are deleted once it passes.
	ExpiresAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	IdleTtl   *durationpb.Duration   `protobuf:"bytes,7,opt,name=idle_ttl,json=idleTtl,proto3" json:"idle_ttl,omitempty"`
	// The thread's database ("DB_..."), created with the thread.
	DatabaseId    string `protobuf:"bytes,8,opt,name=database_id,json=databaseId,proto3" json:"database_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentThread_Thread) ProtoMessage() {}

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

func (x *AgentThread_Thread) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

func (x *AgentThread_Thread) GetScope() string {
	if x != nil {
		return x.Scope
	}
	return ""
}

func (x *AgentThread_Thread) GetAttributes() map[string]string {
	if x != nil {
		return x.Attributes
	}
	return nil
}

func (x *AgentThread_Thread) GetCreatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.CreatedAt
	}
	return nil
}

func (x *AgentThread_Thread) GetLastActive() *timestamppb.Timestamp {
	if x != nil {
		return x.LastActive
	}
	return nil
}

func (x *AgentThread_Thread) GetExpiresAt() *timestamppb.Timestamp {
	if x != nil {
		return x.ExpiresAt
	}
	return nil
}

func (x *AgentThread_Thread) GetIdleTtl() *durationpb.Duration {
	if x != nil {
		return x.IdleTtl
	}
	return nil
}

func (x *AgentThread_Thread) GetDatabaseId() string {
	if x != nil {
		return x.DatabaseId
	}
	return ""
}

// A thread's tasks, oldest first.
type AgentTask_GetTasksRequest struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	ThreadId string                 `protobuf:"bytes,1,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"`
	// Unset for every status.
	Status *AgentTask_Status `protobuf:"varint,2,opt,name=status,proto3,enum=livekit.agent.AgentTask_Status,oneof" json:"status,omitempty"`
	// next_page_token of the previous GetTasksResponse; empty for the first page.
	PageToken     string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	Limit         int32  `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentTask_GetTasksRequest) ProtoMessage() {}

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

func (x *AgentTask_GetTasksRequest) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

func (x *AgentTask_GetTasksRequest) GetStatus() AgentTask_Status {
	if x != nil && x.Status != nil {
		return *x.Status
	}
	return AgentTask_UNSPECIFIED
}

func (x *AgentTask_GetTasksRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

func (x *AgentTask_GetTasksRequest) GetLimit() int32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

type AgentTask_GetTasksResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Tasks []*AgentTask_Task      `protobuf:"bytes,1,rep,name=tasks,proto3" json:"tasks,omitempty"`
	// Empty when exhausted.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentTask_GetTasksResponse) ProtoMessage() {}

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

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

func (x *AgentTask_GetTasksResponse) GetTasks() []*AgentTask_Task {
	if x != nil {
		return x.Tasks
	}
	return nil
}

func (x *AgentTask_GetTasksResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

type AgentTask_Task struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	TaskId   string                 `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	ThreadId string                 `protobuf:"bytes,2,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"`
	// The task's name, as the agent defines it.
	Name          string                 `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Status        AgentTask_Status       `protobuf:"varint,4,opt,name=status,proto3,enum=livekit.agent.AgentTask_Status" json:"status,omitempty"`
	UpdatedAt     *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentTask_Task) ProtoMessage() {}

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

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

func (x *AgentTask_Task) GetTaskId() string {
	if x != nil {
		return x.TaskId
	}
	return ""
}

func (x *AgentTask_Task) GetThreadId() string {
	if x != nil {
		return x.ThreadId
	}
	return ""
}

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

func (x *AgentTask_Task) GetStatus() AgentTask_Status {
	if x != nil {
		return x.Status
	}
	return AgentTask_UNSPECIFIED
}

func (x *AgentTask_Task) GetUpdatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.UpdatedAt
	}
	return nil
}

var File_agent_livekit_agent_thread_proto protoreflect.FileDescriptor

const file_agent_livekit_agent_thread_proto_rawDesc = "" +
	"\n" +
	" agent/livekit_agent_thread.proto\x12\rlivekit.agent\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a!agent/livekit_agent_session.proto\x1a\x14logger/options.proto\"\x89\x0f\n" +
	"\vAgentThread\x1a\xfe\x01\n" +
	"\rCreateRequest\x12\x19\n" +
	"\x05scope\x18\x01 \x01(\tB\x03\xc0P\x01R\x05scope\x12]\n" +
	"\n" +
	"attributes\x18\x02 \x03(\v28.livekit.agent.AgentThread.CreateRequest.AttributesEntryB\x03\xc0P\x01R\n" +
	"attributes\x124\n" +
	"\bidle_ttl\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\aidleTtl\x1a=\n" +
	"\x0fAttributesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a6\n" +
	"\n" +
	"GetRequest\x12(\n" +
	"\tthread_id\x18\x01 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x1a]\n" +
	"\vListRequest\x12\x19\n" +
	"\x05scope\x18\x01 \x01(\tB\x03\xc0P\x01R\x05scope\x12\x1d\n" +
	"\n" +
	"page_token\x18\x02 \x01(\tR\tpageToken\x12\x14\n" +
	"\x05limit\x18\x03 \x01(\x05R\x05limit\x1as\n" +
	"\fListResponse\x12;\n" +
	"\athreads\x18\x01 \x03(\v2!.livekit.agent.AgentThread.ThreadR\athreads\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\x1a\x8d\x02\n" +
	"\rUpdateRequest\x12(\n" +
	"\tthread_id\x18\x01 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x12]\n" +
	"\n" +
	"attributes\x18\x02 \x03(\v28.livekit.agent.AgentThread.UpdateRequest.AttributesEntryB\x03\xc0P\x01R\n" +
	"attributes\x124\n" +
	"\bidle_ttl\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\aidleTtl\x1a=\n" +
	"\x0fAttributesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a9\n" +
	"\rDeleteRequest\x12(\n" +
	"\tthread_id\x18\x01 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x1a\x10\n" +
	"\x0eDeleteResponse\x1a\xcb\x01\n" +
	"\x0fGetItemsRequest\x12(\n" +
	"\tthread_id\x18\x01 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x12\x14\n" +
	"\x05agent\x18\x02 \x01(\tR\x05agent\x12\x1d\n" +
	"\n" +
	"page_token\x18\x03 \x01(\tR\tpageToken\x12\x14\n" +
	"\x05limit\x18\x04 \x01(\x05R\x05limit\x12C\n" +
	"\n" +
	"sort_order\x18\x05 \x01(\x0e2$.livekit.agent.AgentThread.SortOrderR\tsortOrder\x1aq\n" +
	"\x10GetItemsResponse\x125\n" +
	"\x05items\x18\x01 \x03(\v2\x1f.livekit.agent.AgentThread.ItemR\x05items\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\x1a\x8b\x01\n" +
	"\x04Item\x12\x14\n" +
	"\x05agent\x18\x01 \x01(\tR\x05agent\x12\x10\n" +
	"\x03seq\x18\x02 \x01(\x03R\x03seq\x12\x1d\n" +
	"\n" +
	"message_id\x18\x03 \x01(\tR\tmessageId\x12<\n" +
	"\x04item\x18\x04 \x01(\v2#.livekit.agent.ChatContext.ChatItemB\x03\xc0P\x01R\x04item\x1a\xee\x03\n" +
	"\x06Thread\x12(\n" +
	"\tthread_id\x18\x01 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x12\x19\n" +
	"\x05scope\x18\x02 \x01(\tB\x03\xc0P\x01R\x05scope\x12V\n" +
	"\n" +
	"attributes\x18\x03 \x03(\v21.livekit.agent.AgentThread.Thread.AttributesEntryB\x03\xc0P\x01R\n" +
	"attributes\x129\n" +
	"\n" +
	"created_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x12;\n" +
	"\vlast_active\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"lastActive\x129\n" +
	"\n" +
	"expires_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\texpiresAt\x124\n" +
	"\bidle_ttl\x18\a \x01(\v2\x19.google.protobuf.DurationR\aidleTtl\x12\x1f\n" +
	"\vdatabase_id\x18\b \x01(\tR\n" +
	"databaseId\x1a=\n" +
	"\x0fAttributesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"P\n" +
	"\tSortOrder\x12\x1a\n" +
	"\x16SORT_ORDER_UNSPECIFIED\x10\x00\x12\x12\n" +
	"\x0eSORT_ORDER_ASC\x10\x01\x12\x13\n" +
	"\x0fSORT_ORDER_DESC\x10\x02\"\xdd\x04\n" +
	"\tAgentTask\x1a\xb9\x01\n" +
	"\x0fGetTasksRequest\x12(\n" +
	"\tthread_id\x18\x01 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x12<\n" +
	"\x06status\x18\x02 \x01(\x0e2\x1f.livekit.agent.AgentTask.StatusH\x00R\x06status\x88\x01\x01\x12\x1d\n" +
	"\n" +
	"page_token\x18\x03 \x01(\tR\tpageToken\x12\x14\n" +
	"\x05limit\x18\x04 \x01(\x05R\x05limitB\t\n" +
	"\a_status\x1ao\n" +
	"\x10GetTasksResponse\x123\n" +
	"\x05tasks\x18\x01 \x03(\v2\x1d.livekit.agent.AgentTask.TaskR\x05tasks\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\x1a\xd1\x01\n" +
	"\x04Task\x12\x17\n" +
	"\atask_id\x18\x01 \x01(\tR\x06taskId\x12(\n" +
	"\tthread_id\x18\x02 \x01(\tB\v\xbaP\bthreadIDR\bthreadId\x12\x12\n" +
	"\x04name\x18\x03 \x01(\tR\x04name\x127\n" +
	"\x06status\x18\x04 \x01(\x0e2\x1f.livekit.agent.AgentTask.StatusR\x06status\x129\n" +
	"\n" +
	"updated_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\"O\n" +
	"\x06Status\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\v\n" +
	"\aRUNNING\x10\x01\x12\r\n" +
	"\tCOMPLETED\x10\x02\x12\n" +
	"\n" +
	"\x06FAILED\x10\x03\x12\f\n" +
	"\bCANCELED\x10\x04B+Z)github.com/livekit/protocol/livekit/agentb\x06proto3"

var (
	file_agent_livekit_agent_thread_proto_rawDescOnce sync.Once
	file_agent_livekit_agent_thread_proto_rawDescData []byte
)

func file_agent_livekit_agent_thread_proto_rawDescGZIP() []byte {
	file_agent_livekit_agent_thread_proto_rawDescOnce.Do(func() {
		file_agent_livekit_agent_thread_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agent_livekit_agent_thread_proto_rawDesc), len(file_agent_livekit_agent_thread_proto_rawDesc)))
	})
	return file_agent_livekit_agent_thread_proto_rawDescData
}

var file_agent_livekit_agent_thread_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_agent_livekit_agent_thread_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
var file_agent_livekit_agent_thread_proto_goTypes = []any{
	(AgentThread_SortOrder)(0),           // 0: livekit.agent.AgentThread.SortOrder
	(AgentTask_Status)(0),                // 1: livekit.agent.AgentTask.Status
	(*AgentThread)(nil),                  // 2: livekit.agent.AgentThread
	(*AgentTask)(nil),                    // 3: livekit.agent.AgentTask
	(*AgentThread_CreateRequest)(nil),    // 4: livekit.agent.AgentThread.CreateRequest
	(*AgentThread_GetRequest)(nil),       // 5: livekit.agent.AgentThread.GetRequest
	(*AgentThread_ListRequest)(nil),      // 6: livekit.agent.AgentThread.ListRequest
	(*AgentThread_ListResponse)(nil),     // 7: livekit.agent.AgentThread.ListResponse
	(*AgentThread_UpdateRequest)(nil),    // 8: livekit.agent.AgentThread.UpdateRequest
	(*AgentThread_DeleteRequest)(nil),    // 9: livekit.agent.AgentThread.DeleteRequest
	(*AgentThread_DeleteResponse)(nil),   // 10: livekit.agent.AgentThread.DeleteResponse
	(*AgentThread_GetItemsRequest)(nil),  // 11: livekit.agent.AgentThread.GetItemsRequest
	(*AgentThread_GetItemsResponse)(nil), // 12: livekit.agent.AgentThread.GetItemsResponse
	(*AgentThread_Item)(nil),             // 13: livekit.agent.AgentThread.Item
	(*AgentThread_Thread)(nil),           // 14: livekit.agent.AgentThread.Thread
	nil,                                  // 15: livekit.agent.AgentThread.CreateRequest.AttributesEntry
	nil,                                  // 16: livekit.agent.AgentThread.UpdateRequest.AttributesEntry
	nil,                                  // 17: livekit.agent.AgentThread.Thread.AttributesEntry
	(*AgentTask_GetTasksRequest)(nil),    // 18: livekit.agent.AgentTask.GetTasksRequest
	(*AgentTask_GetTasksResponse)(nil),   // 19: livekit.agent.AgentTask.GetTasksResponse
	(*AgentTask_Task)(nil),               // 20: livekit.agent.AgentTask.Task
	(*durationpb.Duration)(nil),          // 21: google.protobuf.Duration
	(*ChatContext_ChatItem)(nil),         // 22: livekit.agent.ChatContext.ChatItem
	(*timestamppb.Timestamp)(nil),        // 23: google.protobuf.Timestamp
}
var file_agent_livekit_agent_thread_proto_depIdxs = []int32{
	15, // 0: livekit.agent.AgentThread.CreateRequest.attributes:type_name -> livekit.agent.AgentThread.CreateRequest.AttributesEntry
	21, // 1: livekit.agent.AgentThread.CreateRequest.idle_ttl:type_name -> google.protobuf.Duration
	14, // 2: livekit.agent.AgentThread.ListResponse.threads:type_name -> livekit.agent.AgentThread.Thread
	16, // 3: livekit.agent.AgentThread.UpdateRequest.attributes:type_name -> livekit.agent.AgentThread.UpdateRequest.AttributesEntry
	21, // 4: livekit.agent.AgentThread.UpdateRequest.idle_ttl:type_name -> google.protobuf.Duration
	0,  // 5: livekit.agent.AgentThread.GetItemsRequest.sort_order:type_name -> livekit.agent.AgentThread.SortOrder
	13, // 6: livekit.agent.AgentThread.GetItemsResponse.items:type_name -> livekit.agent.AgentThread.Item
	22, // 7: livekit.agent.AgentThread.Item.item:type_name -> livekit.agent.ChatContext.ChatItem
	17, // 8: livekit.agent.AgentThread.Thread.attributes:type_name -> livekit.agent.AgentThread.Thread.AttributesEntry
	23, // 9: livekit.agent.AgentThread.Thread.created_at:type_name -> google.protobuf.Timestamp
	23, // 10: livekit.agent.AgentThread.Thread.last_active:type_name -> google.protobuf.Timestamp
	23, // 11: livekit.agent.AgentThread.Thread.expires_at:type_name -> google.protobuf.Timestamp
	21, // 12: livekit.agent.AgentThread.Thread.idle_ttl:type_name -> google.protobuf.Duration
	1,  // 13: livekit.agent.AgentTask.GetTasksRequest.status:type_name -> livekit.agent.AgentTask.Status
	20, // 14: livekit.agent.AgentTask.GetTasksResponse.tasks:type_name -> livekit.agent.AgentTask.Task
	1,  // 15: livekit.agent.AgentTask.Task.status:type_name -> livekit.agent.AgentTask.Status
	23, // 16: livekit.agent.AgentTask.Task.updated_at:type_name -> google.protobuf.Timestamp
	17, // [17:17] is the sub-list for method output_type
	17, // [17:17] is the sub-list for method input_type
	17, // [17:17] is the sub-list for extension type_name
	17, // [17:17] is the sub-list for extension extendee
	0,  // [0:17] is the sub-list for field type_name
}

func init() { file_agent_livekit_agent_thread_proto_init() }
func file_agent_livekit_agent_thread_proto_init() {
	if File_agent_livekit_agent_thread_proto != nil {
		return
	}
	file_agent_livekit_agent_session_proto_init()
	file_agent_livekit_agent_thread_proto_msgTypes[16].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agent_livekit_agent_thread_proto_rawDesc), len(file_agent_livekit_agent_thread_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   19,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_agent_livekit_agent_thread_proto_goTypes,
		DependencyIndexes: file_agent_livekit_agent_thread_proto_depIdxs,
		EnumInfos:         file_agent_livekit_agent_thread_proto_enumTypes,
		MessageInfos:      file_agent_livekit_agent_thread_proto_msgTypes,
	}.Build()
	File_agent_livekit_agent_thread_proto = out.File
	file_agent_livekit_agent_thread_proto_goTypes = nil
	file_agent_livekit_agent_thread_proto_depIdxs = nil
}